commit
401084bab3
265 files changed
+69224
No files matched your search
@@ -0,0 +1,291 @@
|
||||
// SPDX-FileCopyrightText: 2026 Scientific Computing Studio, LLC
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// The Mojo corpus as the app sees it: the generated modules agree with library/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('../library/mojo/pin.json', import.meta.url), 'utf8'));
|
||||
|
||||
test('the generated pin is library/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('every document names the pinned Mojo version, and no other', () => {
|
||||
// a bump moves the pin in library/mojo/pin.json; these are the sentences that have to move with it
|
||||
const docs = ['README.md', 'AGENTS.md', ...fs.readdirSync(new URL('../docs', import.meta.url)).filter((f) => f.endsWith('.md')).map((f) => `docs/${f}`)];
|
||||
const wrong = [];
|
||||
for (const d of docs) {
|
||||
const text = fs.readFileSync(new URL(`../${d}`, import.meta.url), 'utf8');
|
||||
text.split('\n').forEach((line, i) => {
|
||||
for (const m of line.matchAll(/(?:pinned to (?:\*\*)?(?:Mojo )?|verified on Mojo |with Mojo )(\d+\.\d+\.\d+)/g)) if (m[1] !== MOJO_VERSION) wrong.push(`${d}:${i + 1} says ${m[1]}`);
|
||||
});
|
||||
}
|
||||
assert.deepEqual(wrong, [], `the pin is Mojo ${MOJO_VERSION}`);
|
||||
assert.match(fs.readFileSync(new URL('../README.md', import.meta.url), 'utf8'), new RegExp(`pinned to \\*\\*Mojo ${MOJO_VERSION.replace(/\./g, '\\.')}\\*\\*`));
|
||||
assert.match(fs.readFileSync(new URL('../pixi.toml', import.meta.url), 'utf8'), new RegExp(`^mojo = "==${MOJO_VERSION.replace(/\./g, '\\.')}"`, 'm'), 'pixi.toml installs the pinned compiler');
|
||||
});
|
||||
|
||||
test('the generated words are the pinned 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, 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']);
|
||||
// under CI a missing python3 fails this instead of skipping it (a skip in CI is how a gap hides); pixi brings python
|
||||
test('the corpus pipeline tests pass (python3)', { skip: py.status !== 0 && !process.env.CI ? 'python3 is not installed' : false }, () => {
|
||||
assert.equal(py.status, 0, 'python3 is not installed, and CI must run this');
|
||||
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
|
||||
* (library/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, normalizeAnswer, compilerDiagnostics, listingFunctions, demangle, sourceOf as lineSource, BUILD_ARGS, BUILD_LEVELS, mojoBuildArgs } 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('../library/mojo/golden/', import.meta.url)).filter((f) => /^[0-9a-f]{64}\.json$/.test(f))
|
||||
.map((f) => JSON.parse(fs.readFileSync(new URL(`../library/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(`../library/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('../library/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 ${MOJO_VERSION} 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 = normalizeAnswer(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);
|
||||
// since Mojo 1.2.0 a build carries line tables without being asked, so each instruction arrives with `; mojo line N`
|
||||
const code = (l) => l.replace(/\s*;.*$/, '').trim();
|
||||
assert.deepEqual(sim.source.split('\n').map(code).filter((l) => l && !l.endsWith(':')), ['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 = normalizeAnswer(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('../library/mojo/probes/godbolt-compile-button.mojo', import.meta.url), 'utf8');
|
||||
const args = /^# args: (.*)$/m.exec(text)[1].trim();
|
||||
assert.equal(BUILD_LEVELS.O0, args, 'change the probe and re-verify before changing the button');
|
||||
assert.equal(BUILD_ARGS.O0, mojoBuildArgs(args), 'the button sends the pin\'s build arguments, then its level\'s');
|
||||
const g = goldens.find((x) => x.firstItem === 'probes/godbolt-compile-button' && x.args === BUILD_ARGS.O0);
|
||||
assert.ok(g, 'godbolt has answered the probe with exactly the arguments the button sends: pixi run mojo-verify');
|
||||
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(normalizeAnswer(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(normalizeAnswer(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(normalizeAnswer(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