Move the engine core into core/, a project of its own (pplus-core)
What programs mean (the languages, translators, Mojo checker and
interpreter, prover, fuzzer, machine model, catalog problems and the Mojo
corpus with godbolt's stored answers) was mixed into the site's tree, so a
change to the prover and a change to a button went through the same gate
and the same docs. This moves all of it under core/, laid out as its own
repository, ready to be extracted with its history and pinned here as a
git submodule.
- core/: src/{engines,services,sync,mojo,exercises,curriculum,common},
mojo/, syntax/mojo.xml, its tests (with Workspace and workForProblem in
place of the site's Session), scripts (corpus pipeline, play, the
exercise and probe starters, engines export/diff), and its docs
(engines, trust, mojo-corpus, exercises, coverage). Its own pixi.toml,
package.json, README, AGENTS.md and CI workflow.
- core/tests/boundary.test.mjs: library modules use no DOM, import no
page widget, and import nothing outside src/.
- core/scripts/cli.mjs: pixi run cli check|run|prove|fuzz|translate.
- core/scripts/dafny.py: Dafny 4.11.0 pinned by version and SHA-256 per
platform, fetched into .tools/ (pixi run dafny-fetch, pixi run dafny).
- The site imports core only as #core/<path>.js: an import map in
index.html, "imports" in package.json for node, core's declarations for
tsc. The site's TypeScript builds core first (npm run build).
- assemble.sh, the Quarto engine copy, the render cache key, check-pages,
quarto-export and quarto-css read core/dist and core/mojo; quarto-css
copies core's syntax/mojo.xml into the extension.
- Site tests that covered engines moved to core; the rest keep Session.
- README, AGENTS.md, docs/app.md, docs/deploy.md and the CI workflow
describe the split (checkout with submodules; core's tests and corpus
status run against the pinned commit).
Gate: site 110 pass; core 307 pass; corpus status --strict passes.
Manual check: the assembled site opens Bridge (count-base-proved),
Developer and Hardware (count-base) with the editor, the stepper and the
board, and no module errors.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
This commit is contained in:
1 parent
961a59054d
commit
c5157fcad5
56 files changed
+3386
-66
No files matched your search
@@ -0,0 +1,269 @@
|
||||
// The Mojo corpus as the app sees it: the generated modules agree with mojo/pin.json
|
||||
// and the harvested corpus, and the Python pipeline's own tests pass.
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import { MOJO_VERSION, GODBOLT_BASE, GODBOLT_COMPILER, MOJO_SOURCES } from '../dist/mojo/generated/pin.js';
|
||||
import { MOJO_KEYWORDS, MOJO_SOFT_KEYWORDS, MOJO_REMOVED_WORDS, MOJO_DECORATORS, MOJO_PRELUDE, MOJO_PUNCTUATION } from '../dist/mojo/generated/tokens.js';
|
||||
import { Workspace } from '../dist/common/workspace.js';
|
||||
import { PROBLEMS, problemById, workForProblem } from '../dist/common/problems.js';
|
||||
|
||||
const pin = JSON.parse(fs.readFileSync(new URL('../mojo/pin.json', import.meta.url), 'utf8'));
|
||||
|
||||
test('the generated pin is mojo/pin.json', () => {
|
||||
assert.equal(MOJO_VERSION, pin.mojo.version);
|
||||
assert.equal(GODBOLT_BASE, pin.godbolt.base);
|
||||
assert.equal(GODBOLT_COMPILER, pin.godbolt.compiler);
|
||||
assert.deepEqual(Object.keys(MOJO_SOURCES).sort(), Object.keys(pin.sources).sort());
|
||||
});
|
||||
|
||||
test('the generated words are the 1.1.0 language', () => {
|
||||
for (const w of ['def', 'struct', 'trait', 'var', 'ref', 'comptime', 'raise', 'Self']) assert.ok(MOJO_KEYWORDS.includes(w), w);
|
||||
assert.ok(!MOJO_KEYWORDS.includes('fn'), 'fn is removed in 1.1.0, not a keyword to highlight as valid');
|
||||
assert.equal(MOJO_REMOVED_WORDS.fn, 'def');
|
||||
assert.equal(MOJO_REMOVED_WORDS.read, 'imm');
|
||||
for (const w of ['imm', 'mut', 'out', 'deinit']) assert.ok(MOJO_SOFT_KEYWORDS.includes(w), w);
|
||||
for (const d of ['fieldwise_init', 'always_inline', 'export']) assert.ok(MOJO_DECORATORS.includes(d), d);
|
||||
for (const n of ['Int', 'String', 'List', 'Dict', 'Optional', 'print', 'input', 'range', 'len']) assert.ok(MOJO_PRELUDE.includes(n), n);
|
||||
assert.ok(MOJO_PUNCTUATION.indexOf('**=') < MOJO_PUNCTUATION.indexOf('**'), 'longest spellings first');
|
||||
});
|
||||
|
||||
const py = spawnSync('python3', ['--version']);
|
||||
test('the corpus pipeline tests pass (python3)', { skip: py.status !== 0 ? 'python3 is not installed' : false }, () => {
|
||||
const r = spawnSync('python3', ['-m', 'unittest', 'discover', '-s', 'scripts/mojo/tests'], { encoding: 'utf8', cwd: new URL('..', import.meta.url).pathname });
|
||||
assert.equal(r.status, 0, r.stderr.split('\n').slice(-30).join('\n'));
|
||||
});
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* Stage 1: the Mojo pane. Wherever possible these use godbolt's real answers
|
||||
* (mojo/golden), so they test against what the compiler said, not what we assume.
|
||||
* ------------------------------------------------------------------------- */
|
||||
import { tokenizeMojo } from '../dist/mojo/tokenize.js';
|
||||
import { removedSyntax } from '../dist/mojo/check.js';
|
||||
import { nextIndent } from '../dist/mojo/editing.js';
|
||||
import { mojoRequestBody, mojoRequestUrl, normaliseAnswer, compilerDiagnostics, listingFunctions, demangle, sourceOf as lineSource, BUILD_ARGS } from '../dist/services/godbolt.js';
|
||||
import { intelLine, labelMap, forSimulator } from '../dist/mojo/att.js';
|
||||
import { parseAsm, runAsmProgram } from '../dist/services/asm.js';
|
||||
import { runMojo } from '../dist/mojo/interp.js';
|
||||
import { parseModule } from '../dist/mojo/parse.js';
|
||||
import { MOJO_PROGRAMS } from '../dist/mojo/generated/programs.js';
|
||||
|
||||
const ROOT = new URL('..', import.meta.url).pathname;
|
||||
const goldens = fs.readdirSync(new URL('../mojo/golden/', import.meta.url)).filter((f) => /^[0-9a-f]{64}\.json$/.test(f))
|
||||
.map((f) => JSON.parse(fs.readFileSync(new URL(`../mojo/golden/${f}`, import.meta.url), 'utf8')));
|
||||
/** godbolt's answer for one corpus item, rebuilt as the raw JSON the browser receives. */
|
||||
function answerFor(item) {
|
||||
const g = goldens.find((x) => x.firstItem === item);
|
||||
assert.ok(g, `no golden for ${item}; run pixi run mojo-verify`);
|
||||
const source = (a) => a.line ? { line: a.line, ...('file' in a ? { file: a.file } : {}), ...('main' in a ? { mainsource: a.main } : {}) } : null;
|
||||
return { golden: g, raw: { ...g.raw, asm: (g.result.asm || []).map((a) => ({ text: a.text, source: source(a) })) } };
|
||||
}
|
||||
const sourceOf = (item) => fs.readFileSync(new URL(`../mojo/${item.replace('probes/', 'probes/')}.mojo`, import.meta.url), 'utf8');
|
||||
function applyFix(src, f) {
|
||||
const lines = src.split('\n'); const l = lines[f.line - 1];
|
||||
lines[f.line - 1] = l.slice(0, f.col - 1) + f.text + l.slice(f.endCol == null ? l.length : f.endCol - 1);
|
||||
return lines.join('\n');
|
||||
}
|
||||
const kinds = (line) => tokenizeMojo(line)[0].filter((t) => t.cls).map((t) => `${t.cls.replace('tok-', '')}:${t.text}`);
|
||||
|
||||
test('highlighting agrees with the Mojo grammar\'s own tests', () => {
|
||||
const { cases } = JSON.parse(fs.readFileSync(new URL('../mojo/corpus/syntax/cases.json', import.meta.url), 'utf8'));
|
||||
assert.ok(cases.length >= 20);
|
||||
for (const c of cases) {
|
||||
const toks = tokenizeMojo(c.text)[0];
|
||||
let at = 0; const hit = toks.find((t) => { const ok = c.start >= at && c.start < at + t.text.length; at += t.text.length; return ok; });
|
||||
const isKeyword = hit?.cls === 'tok-keyword';
|
||||
const wantsKeyword = c.scopes.some((x) => /^(keyword|storage)\./.test(x));
|
||||
// syntax 1.1.0 removed (alias) is not a keyword any more, whatever the grammar says
|
||||
const expected = c.dialect?.older ? false : wantsKeyword;
|
||||
assert.equal(isKeyword, expected, `${c.file}:${c.line} ${JSON.stringify(c.slice)} in ${JSON.stringify(c.text)} wants ${c.scopes.join(' ')}`);
|
||||
}
|
||||
});
|
||||
|
||||
test('highlighting: docstrings span lines, ^ transfers or XORs, conventions are ownership words', () => {
|
||||
const doc = tokenizeMojo('def f():\n """One\n two."""\n return 1');
|
||||
assert.ok(doc[1].some((t) => t.cls === 'tok-string') && doc[2].every((t) => !t.text.trim() || t.cls === 'tok-string'));
|
||||
assert.ok(doc[3].some((t) => t.cls === 'tok-keyword' && t.text === 'return'));
|
||||
assert.ok(kinds('consume(b^, c)').includes('transfer:^'));
|
||||
assert.ok(kinds('var b = a^').includes('transfer:^'));
|
||||
assert.ok(kinds('var m = f ^ 0xFF').includes('op:^'));
|
||||
assert.deepEqual(kinds('def g(mut self, var x: Int, deinit other: T):').filter((k) => k.startsWith('convention')), ['convention:mut', 'convention:var', 'convention:deinit']);
|
||||
assert.ok(kinds(' var name: String').includes('keyword:var'), 'a field declaration is not a convention');
|
||||
assert.ok(kinds('def h(read x: Int):').includes('error:read'));
|
||||
assert.ok(kinds('var data = file.read()').includes('name:read'), 'read is only an error as a convention');
|
||||
assert.ok(kinds('fn old():').includes('error:fn'));
|
||||
assert.ok(kinds('@fieldwise_init').includes('label:fieldwise_init'));
|
||||
assert.ok(kinds('print(t"n={n * 2}")').includes('name:n'), 't-string interpolations highlight as code');
|
||||
});
|
||||
|
||||
test('removed syntax is caught before compiling, in the compiler\'s words, with its fix', () => {
|
||||
const src = 'fn main():\n show(1)\n\ndef show(read x: Int):\n print(x)\n';
|
||||
const ds = removedSyntax(src);
|
||||
assert.deepEqual(ds.map((d) => [d.line, d.message]), [[1, "'fn' has been removed; use 'def' instead"], [4, "'read' was removed; use 'imm'"]]);
|
||||
let fixed = src;
|
||||
for (const d of [...ds].reverse()) fixed = applyFix(fixed, d.fix);
|
||||
assert.equal(fixed, 'def main():\n show(1)\n\ndef show(imm x: Int):\n print(x)\n');
|
||||
assert.deepEqual(removedSyntax(fixed), []);
|
||||
// and it is exactly what the real compiler said about the fn probe
|
||||
const real = compilerDiagnostics(goldens.find((g) => g.firstItem === 'probes/dialect-fn').result.buildStderr);
|
||||
assert.equal(real[0].message, ds[0].message);
|
||||
const realRead = compilerDiagnostics(goldens.find((g) => g.firstItem === 'probes/dialect-read').result.buildStderr);
|
||||
assert.equal(realRead[0].message, ds[1].message);
|
||||
});
|
||||
|
||||
test('Enter indents after a block opener and dedents after return', () => {
|
||||
assert.equal(nextIndent('def f(x: Int) -> Int:', ' '), ' ');
|
||||
assert.equal(nextIndent(' comptime for i in range(3):', ' '), ' ');
|
||||
assert.equal(nextIndent(' return x # done', ' '), ' ');
|
||||
assert.equal(nextIndent(' var y = 1', ' '), ' ');
|
||||
});
|
||||
|
||||
test('the Compile button asks godbolt exactly what the corpus harness asks', () => {
|
||||
const src = 'def main():\n print(input())\n';
|
||||
const py = spawnSync('python3', ['-c', `import sys, json; sys.path.insert(0, 'scripts/mojo')\nfrom mojocorpus import godbolt\nprint(json.dumps(godbolt.request_body(${JSON.stringify(src)}, 'both', '7\\n', '-O0')))`], { encoding: 'utf8', cwd: ROOT });
|
||||
if (py.status !== 0) return; // no python3 here; the pipeline tests cover the Python side
|
||||
assert.deepEqual(mojoRequestBody(src, '7\n', '-O0'), JSON.parse(py.stdout));
|
||||
assert.equal(mojoRequestUrl(), `${pin.godbolt.base}/api/compiler/${pin.godbolt.compiler}/compile`);
|
||||
});
|
||||
|
||||
test('compiler errors land on their lines, and its fix-its become one-click fixes', () => {
|
||||
// The probes were asked in run mode, where errors come in buildResult; the button's mode puts them in stderr. Same text.
|
||||
const stderrOf = (item) => goldens.find((g) => g.firstItem === item).result.buildStderr;
|
||||
const fnDiag = compilerDiagnostics(stderrOf('probes/dialect-fn'));
|
||||
assert.equal(fnDiag[0].line, 3);
|
||||
assert.equal(applyFix(sourceOf('probes/dialect-fn'), fnDiag[0].fix).split('\n')[2], 'def main():');
|
||||
const copy = compilerDiagnostics(stderrOf('probes/check-implicit-copy'));
|
||||
const err = copy.find((d) => d.severity === 'error');
|
||||
assert.match(err.message, /cannot be implicitly copied/);
|
||||
assert.equal(err.origin, 'the Mojo 1.1.0 compiler');
|
||||
const fixes = err.question.options.map((o) => applyFix(sourceOf('probes/check-implicit-copy'), o).split('\n')[err.line - 1].trim());
|
||||
assert.deepEqual(fixes, ['var b = a^', 'var b = a.copy()']);
|
||||
const alias = compilerDiagnostics(stderrOf('probes/check-aliasing'));
|
||||
assert.match(alias[0].message, /aliasing values passed mutably to 's' argument/);
|
||||
assert.ok(alias.slice(1).every((d) => d.severity === 'note'));
|
||||
assert.deepEqual(compilerDiagnostics(stderrOf('probes/check-use-after-move')).map((d) => [d.severity, d.message]),
|
||||
[['error', "use of uninitialized value 'a'"], ['note', "'a' declared here"]]);
|
||||
});
|
||||
|
||||
test('the real listing of add, translated to Intel, runs on the model machine', () => {
|
||||
const ans = normaliseAnswer(answerFor('probes/godbolt-opt-O0').raw);
|
||||
const fns = listingFunctions(ans.asm);
|
||||
assert.deepEqual(fns.filter((f) => f.kind === 'user').map((f) => f.name), ['add(Int, Int)', 'main()']);
|
||||
assert.deepEqual(fns.filter((f) => f.kind === 'entry').map((f) => f.name), ['main']);
|
||||
const add = fns.find((f) => f.name === 'add(Int, Int)');
|
||||
const sim = forSimulator(fns, add);
|
||||
assert.deepEqual(sim.source.split('\n').filter((l) => l.trim() && !l.trim().endsWith(':') && !l.includes(';')).map((l) => l.trim()), ['mov rax, rdi', 'add rax, rsi', 'ret']);
|
||||
const run = runAsmProgram(parseAsm(sim.source), { setup: 'rdi = 2\nrsi = 3' });
|
||||
assert.ok(!run.error, run.error?.message);
|
||||
assert.equal(run.output.at(-1), 'rax = 5 (0x5)');
|
||||
// main calls print, which the model machine cannot run: it assembles with a stub for print, steps up to the call, and stops there saying so
|
||||
const main = forSimulator(fns, fns.find((f) => f.name === 'main()'));
|
||||
assert.ok(main.refusedCalls.some((c) => /print/.test(c)));
|
||||
const mp = parseAsm(main.source);
|
||||
assert.ok(mp.ok, mp.diagnostics.map((d) => d.message).join('; '));
|
||||
const mr = runAsmProgram(mp, { setup: main.data.join('\n') });
|
||||
assert.ok(mr.count > 5, 'main steps its own instructions before the call');
|
||||
assert.match(mr.error.message, /print: standard library, not on the model machine/);
|
||||
});
|
||||
|
||||
test('the optimized listing keeps no function of the user\'s, and one request returned listing and output', () => {
|
||||
const ans = normaliseAnswer(answerFor('probes/godbolt-asm-and-run').raw);
|
||||
assert.equal(ans.stdout, '5');
|
||||
assert.ok(ans.asm.length > 0 && ans.compiled && ans.executed && ans.exitCode === 0);
|
||||
assert.deepEqual(listingFunctions(ans.asm).filter((f) => f.kind === 'user'), []);
|
||||
});
|
||||
|
||||
test('AT&T to Intel: operands reverse, sizes become ptr, names become labels', () => {
|
||||
const m = labelMap([{ label: '"example::add(::SIMD[DType.int, 1],::SIMD[DType.int, 1])"', name: 'add(Int, Int)', kind: 'user', lines: [] }]);
|
||||
const cases = [
|
||||
['movq %rdi, 16(%rsp)', 'mov qword ptr [rsp + 16], rdi'],
|
||||
['movl $0, -4(%rbp)', 'mov dword ptr [rbp - 4], 0'],
|
||||
['movzbl (%rdi,%rcx), %eax', 'movzx eax, byte ptr [rdi + rcx*1]'],
|
||||
['movslq 8(%rsi,%rax,4), %rdx', 'movsxd rdx, dword ptr [rsi + rax*4 + 8]'],
|
||||
['leaq static_string_ab(%rip), %rax', 'lea rax, [rip + static_string_ab]'],
|
||||
['imulq $3, %rsi, %rax', 'imul rax, rsi, 3'],
|
||||
['cmovneq %rcx, %rax', 'cmovne rax, rcx'],
|
||||
['callq "example::add(::SIMD[DType.int, 1],::SIMD[DType.int, 1])"@PLT', 'call add'],
|
||||
['jne .LBB2_2', 'jne .LBB2_2'],
|
||||
['retq', 'ret'],
|
||||
['cqto', 'cqo'],
|
||||
['.cfi_startproc', null],
|
||||
];
|
||||
for (const [att, intel] of cases) assert.equal(intelLine(att, m), intel, att);
|
||||
assert.equal(demangle('"example::add(::SIMD[DType.int, 1],::SIMD[DType.float64, 1])"'), 'add(Int, Float64)');
|
||||
});
|
||||
|
||||
test('an exercise\'s Mojo is a verified program from the corpus', () => {
|
||||
assert.equal(MOJO_PROGRAMS['count-base'].verified, true);
|
||||
const p = PROBLEMS.find((x) => x.id === 'count-base');
|
||||
assert.equal(p.mojo.id, 'count-base');
|
||||
assert.equal(p.sources.mojo, MOJO_PROGRAMS['count-base'].source);
|
||||
assert.ok(workForProblem(p).sources.mojo, 'the state carries the exercise\'s Mojo');
|
||||
for (const q of PROBLEMS) if (q.mojo) assert.ok(MOJO_PROGRAMS[q.mojo.id], `${q.id} names a Mojo program that does not exist`);
|
||||
// every exercise with pseudo has its Mojo too, so the Mojo/pseudo switch always has both sides
|
||||
for (const q of PROBLEMS) if (q.sources.pseudo) assert.ok(q.mojo, `${q.id} has pseudo but no Mojo program`);
|
||||
});
|
||||
|
||||
test('each exercise\'s Mojo prints, in the interpreter, what the exercise expects of the pseudo', () => {
|
||||
const norm = (s) => s.trim().replace(/^"(.*)"$/, '$1').replace(/^TRUE$/, 'True').replace(/^FALSE$/, 'False');
|
||||
for (const q of PROBLEMS) {
|
||||
if (!q.mojo || !q.expect) continue;
|
||||
const r = runMojo(parseModule(q.mojo.source), q.mojo.source, { maxSteps: 200000, record: false });
|
||||
if (r.refused) continue; // the stepper says why; the compiler is the judge
|
||||
assert.equal(norm(r.stdout), norm(q.expect), `${q.id}: its Mojo printed ${JSON.stringify(r.stdout)}`);
|
||||
}
|
||||
});
|
||||
|
||||
test('the Compile button builds with exactly the flags a passing probe verified', () => {
|
||||
const text = fs.readFileSync(new URL('../mojo/probes/godbolt-compile-button.mojo', import.meta.url), 'utf8');
|
||||
const args = /^# args: (.*)$/m.exec(text)[1].trim();
|
||||
assert.equal(BUILD_ARGS.O0, args, 'change the probe and re-verify before changing the button');
|
||||
const g = goldens.find((x) => x.firstItem === 'probes/godbolt-compile-button');
|
||||
if (!g) return; // a checkout without that golden; the corpus tests cover it
|
||||
assert.equal(g.result.compiled && g.result.executed && g.result.exitCode, 0);
|
||||
assert.equal(g.result.stdout.trim(), '5');
|
||||
});
|
||||
|
||||
test('a source line is the program\'s only when godbolt says it comes from the program\'s file', () => {
|
||||
assert.deepEqual(lineSource({ line: 10, file: null }), { line: 10 });
|
||||
assert.deepEqual(lineSource({ line: 10 }), { line: 10 });
|
||||
assert.deepEqual(lineSource({ line: 10, file: '/app/example.mojo' }), { line: 10 });
|
||||
assert.deepEqual(lineSource({ line: 10, file: 'other', mainsource: true }), { line: 10 });
|
||||
assert.deepEqual(lineSource({ line: 218, file: '/opt/mojo/lib/std/io/io.mojo' }), { line: null, from: { file: 'io.mojo', line: 218 } });
|
||||
assert.deepEqual(lineSource({ line: 218, file: null, mainsource: false }), { line: null, from: { file: '?', line: 218 } });
|
||||
assert.deepEqual(lineSource(null), { line: null });
|
||||
});
|
||||
|
||||
test('with line tables, the program\'s own instructions point at the program\'s own lines', (t) => {
|
||||
const g = goldens.find((x) => x.firstItem === 'probes/godbolt-compile-button');
|
||||
if (!g) return t.skip('no golden for probes/godbolt-compile-button');
|
||||
const marked = (g.result.asm || []).some((a) => 'file' in a || 'main' in a);
|
||||
if (!marked) return t.skip("this golden predates file marking; run: pixi run mojo-verify-item 'probes/godbolt-*'");
|
||||
const fns = listingFunctions(normaliseAnswer(answerFor('probes/godbolt-compile-button').raw).asm);
|
||||
const lines = (name) => [...new Set(fns.find((f) => f.name === name).lines.map((l) => l.line).filter((x) => x != null))];
|
||||
assert.deepEqual(lines('add(Int, Int)'), [5, 6]);
|
||||
assert.deepEqual(lines('main()').sort(), [10, 9].sort());
|
||||
assert.ok(fns.find((f) => f.name === 'main()').lines.some((l) => l.from && l.from.file.endsWith('.mojo')), 'print\'s inlined defaults are marked as library code');
|
||||
});
|
||||
|
||||
test('Stage 6: a function\'s calls into the standard library are named, from the real listing', async () => {
|
||||
const g = goldens.find((x) => x.firstItem === 'probes/godbolt-compile-button');
|
||||
if (!g) return;
|
||||
const { libraryCalls } = await import('../dist/ui/views/compiler.js').catch(() => ({ libraryCalls: null }));
|
||||
if (!libraryCalls) return; // the view needs a DOM to load; covered by the browser check
|
||||
const fns = listingFunctions(normaliseAnswer(answerFor('probes/godbolt-compile-button').raw).asm);
|
||||
assert.deepEqual(libraryCalls(fns.find((f) => f.name === 'main()')), ['print (std.io.io)']);
|
||||
assert.deepEqual(libraryCalls(fns.find((f) => f.name === 'add(Int, Int)')), []);
|
||||
});
|
||||
|
||||
test('Stage 6b: code sent to the x86-64 pane keeps each instruction\'s Mojo line', async () => {
|
||||
const g = goldens.find((x) => x.firstItem === 'probes/godbolt-compile-button');
|
||||
if (!g) return;
|
||||
const { forSimulator } = await import('../dist/mojo/att.js');
|
||||
const fns = listingFunctions(normaliseAnswer(answerFor('probes/godbolt-compile-button').raw).asm);
|
||||
const { source } = forSimulator(fns, fns.find((f) => f.name === 'add(Int, Int)'));
|
||||
const marks = source.split('\n').filter((l) => /; mojo line \d+/.test(l)).map((l) => Number(/; mojo line (\d+)/.exec(l)[1]));
|
||||
assert.deepEqual([...new Set(marks)], [5, 6], 'the instructions of add carry lines 5 and 6');
|
||||
});
|
||||
|
||||
Reference in new issue
Block a user