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
269 lines
16 KiB
JavaScript
269 lines
16 KiB
JavaScript
// Stage 4: pseudo -> Mojo. The generated Mojo must be accepted by the checker, run in the interpreter, and
|
|
// print what the pseudo prints; its style is pinned by a snapshot per exercise; every standard-library name
|
|
// it writes is in the harvested index. Programs it cannot yet hold to that are listed below, each with its reason.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { EXERCISES } from '../dist/exercises/index.js';
|
|
import { studyOf, runPseudo } from '../dist/services/pseudo.js';
|
|
import { checkMojo } from '../dist/mojo/check.js';
|
|
import { runMojo } from '../dist/mojo/interp.js';
|
|
import { pseudoToMojo, GENERATED_HEADER, USED_STDLIB, USED_PRELUDE } from '../dist/sync/pseudo-to-mojo.js';
|
|
import { formatAsMojo, sameOutput } from '../dist/sync/compare.js';
|
|
import { MOJO_STD_EXPORTS } from '../dist/mojo/generated/stdlib.js';
|
|
import { MOJO_STD_STRUCTS } from '../dist/mojo/generated/types.js';
|
|
|
|
globalThis.localStorage = { getItem() { return null; }, setItem() { }, removeItem() { } };
|
|
|
|
const here = path.dirname(fileURLToPath(import.meta.url));
|
|
const corpusDir = path.join(here, 'corpus');
|
|
const snapDir = path.join(here, 'snapshots', 'sync-mojo');
|
|
|
|
/**
|
|
* Programs that do not (yet) get the full check, and why. A program leaves this list when it passes;
|
|
* the test fails if a listed program passes, so the list can only shrink.
|
|
* declined: the Mojo interpreter declines the construct (it declines what it has not been verified
|
|
* against godbolt on); the translation is still checked, and the run is not.
|
|
* differs: the notation and Mojo disagree by design, and a literal translation keeps Mojo's behavior.
|
|
* checker: the checker's error is the right answer for what the pseudo says.
|
|
*/
|
|
const KNOWN_GAPS = {
|
|
'ex:match-off-by-one': ['declined', 'the pseudo stops with an index error; the interpreter declines an out-of-range codepoint index'],
|
|
'32-stops.pseudo': ['declined', 'the pseudo stops with an index error; the interpreter declines an out-of-range codepoint index'],
|
|
'08-caesar.pseudo': ['declined', 'chr(...) is not run by the interpreter yet'],
|
|
'24-string-builtins.pseudo': ['declined', 'ord(...) is not run by the interpreter yet'],
|
|
'23-dice.pseudo': ['declined', 'random_si64 is not run by the interpreter yet'],
|
|
'42-numerics.pseudo': ['declined', 'sin and the other math functions are not run by the interpreter yet'],
|
|
'46-projectile.pseudo': ['declined', 'pi is not run by the interpreter yet'],
|
|
'47-binomial-and-ph.pseudo': ['declined', 'comb is not run by the interpreter yet'],
|
|
'33-stops-div.pseudo': ['differs', 'dividing by zero stops the notation; a Float64 division in Mojo gives nan'],
|
|
'44-parallel-race.pseudo': ['differs', 'the notation detects a data race in PARALLEL FOR; Mojo runs the passes in order and prints a result'],
|
|
'45-parallel-neighbour-race.pseudo': ['differs', 'the notation detects a data race in PARALLEL FOR; Mojo runs the passes in order and prints a result'],
|
|
'35-stops-unset.pseudo': ['checker', 'the pseudo reads a variable that was never given a value; the checker reports exactly that, as the compiler would'],
|
|
'36-stops-counter.pseudo': ['checker', 'the pseudo reads a FOR counter after its loop, where it has no value; the checker reports exactly that'],
|
|
};
|
|
|
|
/** Programs whose pseudo does not parse, by design. The translator must say so, not crash. */
|
|
const NO_PSEUDO = new Set(['ex:five-bugs', '37-static-errors.pseudo', '41-reserved-name.pseudo']);
|
|
|
|
const AGREE_AT_LEAST = 48; // raise as the interpreter learns more; counted below
|
|
|
|
function programs() {
|
|
const out = [];
|
|
for (const e of EXERCISES) if (e.sources.pseudo) out.push({ id: `ex:${e.id}`, name: e.id, pseudo: e.sources.pseudo, call: e.call ?? null, input: [] });
|
|
for (const f of fs.readdirSync(corpusDir).filter((x) => x.endsWith('.pseudo')).sort()) {
|
|
const src = fs.readFileSync(path.join(corpusDir, f), 'utf8');
|
|
out.push({ id: f, name: f, pseudo: src, call: null, input: [...src.matchAll(/^\/\/ INPUT: (.*)$/gm)].map((m) => m[1]) });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** How one program fares: what the translator, the checker, the interpreter, and the pseudo run say. */
|
|
function judge(p) {
|
|
const st = studyOf(p.pseudo);
|
|
if (!st.ok) return { verdict: 'no-pseudo', result: pseudoToMojo(p.pseudo, { call: p.call }) };
|
|
const tr = runPseudo(st, { call: p.call, input: p.input, maxSteps: 200000 });
|
|
const result = pseudoToMojo(p.pseudo, { call: p.call });
|
|
assert.ok(!('unsupported' in result), `${p.id}: ${JSON.stringify(result.unsupported)}`);
|
|
const gaps = result.notes.filter((n) => n.id === 'translate-gap');
|
|
const checked = checkMojo(result.source);
|
|
const errors = checked.diagnostics.filter((d) => d.severity === 'error');
|
|
if (gaps.length) return { verdict: 'gap', detail: gaps.map((g) => `line ${g.line}: ${g.message}`).join('; '), result };
|
|
if (errors.length) return { verdict: 'checker', detail: errors.map((d) => `L${d.line} ${d.message}`).join(' | '), result };
|
|
const run = runMojo(checked.module, result.source, { input: p.input, maxSteps: 400000 });
|
|
if (run.refused) return { verdict: 'declined', detail: run.refused, result };
|
|
const stops = run.exitCode !== 0 || run.limited;
|
|
if (tr.error) return stops ? { verdict: 'agree', result } : { verdict: 'differs', detail: `pseudo stops (${tr.error.kind}); Mojo ran to the end and printed ${JSON.stringify(run.stdout.slice(0, 80))}`, result };
|
|
if (stops) return { verdict: 'differs', detail: `Mojo stopped (exit ${run.exitCode}); pseudo printed ${JSON.stringify(tr.output.slice(0, 2))}`, result };
|
|
const want = p.call && tr.raw.result !== undefined
|
|
? [...tr.raw.output, formatAsMojo(tr.raw.result)].join('\n')
|
|
: tr.raw.output.join('\n');
|
|
return sameOutput(want, run.stdout)
|
|
? { verdict: 'agree', result }
|
|
: { verdict: 'differs', detail: `pseudo printed ${JSON.stringify(want.slice(0, 100))}, Mojo printed ${JSON.stringify(run.stdout.slice(0, 100))}`, result };
|
|
}
|
|
|
|
const verdicts = new Map();
|
|
test('every exercise and corpus program: the generated Mojo checks, runs, and agrees with the pseudo, or is a listed gap', () => {
|
|
const unexpected = [];
|
|
let agree = 0;
|
|
for (const p of programs()) {
|
|
const j = judge(p);
|
|
verdicts.set(p.id, j);
|
|
if (j.verdict === 'no-pseudo') {
|
|
if (!NO_PSEUDO.has(p.id)) unexpected.push(`${p.id}: the pseudo does not parse, and the program is not listed in NO_PSEUDO`);
|
|
continue;
|
|
}
|
|
if (NO_PSEUDO.has(p.id)) { unexpected.push(`${p.id}: listed in NO_PSEUDO but its pseudo parses`); continue; }
|
|
const known = KNOWN_GAPS[p.id];
|
|
if (j.verdict === 'agree') {
|
|
agree++;
|
|
if (known) unexpected.push(`${p.id}: now agrees; take it off KNOWN_GAPS (${known[1]})`);
|
|
continue;
|
|
}
|
|
if (!known) { unexpected.push(`${p.id}: ${j.verdict}: ${j.detail}`); continue; }
|
|
if (known[0] !== j.verdict) unexpected.push(`${p.id}: listed as ${known[0]} but is ${j.verdict}: ${j.detail}`);
|
|
}
|
|
assert.deepEqual(unexpected, []);
|
|
assert.ok(agree >= AGREE_AT_LEAST, `${agree} programs agree, fewer than ${AGREE_AT_LEAST}`);
|
|
});
|
|
|
|
test('the pseudo that does not parse gets a reason, not a crash', () => {
|
|
for (const id of NO_PSEUDO) {
|
|
const p = programs().find((x) => x.id === id);
|
|
const r = pseudoToMojo(p.pseudo, { call: p.call });
|
|
assert.ok('unsupported' in r, id);
|
|
assert.ok(r.unsupported.length > 0 && r.unsupported.every((d) => d.severity === 'error'), id);
|
|
}
|
|
});
|
|
|
|
test('every exercise with pseudo has its generated Mojo pinned by a snapshot (UPDATE_SNAPSHOTS=1 rewrites them for review)', () => {
|
|
fs.mkdirSync(snapDir, { recursive: true });
|
|
const wanted = new Set();
|
|
for (const p of programs().filter((x) => x.id.startsWith('ex:'))) {
|
|
const r = pseudoToMojo(p.pseudo, { call: p.call });
|
|
if ('unsupported' in r) continue; // five-bugs: its pseudo has mistakes by design
|
|
const file = path.join(snapDir, `${p.name}.mojo`);
|
|
wanted.add(`${p.name}.mojo`);
|
|
if (process.env.UPDATE_SNAPSHOTS) fs.writeFileSync(file, r.source);
|
|
assert.ok(fs.existsSync(file), `no snapshot for ${p.name}; run with UPDATE_SNAPSHOTS=1 and review the new file`);
|
|
assert.equal(r.source, fs.readFileSync(file, 'utf8'), `the generated Mojo for ${p.name} changed; if the change is wanted, run with UPDATE_SNAPSHOTS=1 and review the diff`);
|
|
}
|
|
for (const f of fs.readdirSync(snapDir)) assert.ok(wanted.has(f), `snapshot ${f} belongs to no exercise`);
|
|
});
|
|
|
|
test('the translation is literal: the declare-then-assign, index-loop, and total = total + 1 habits are kept', () => {
|
|
const ex = EXERCISES.find((e) => e.id === 'count-base');
|
|
const r = pseudoToMojo(ex.sources.pseudo, { call: ex.call });
|
|
for (const line of [' var n: Int', ' var total: Int', ' n = t.count_codepoints()', ' total = 0', ' for i in range(n):', ' if String(t[codepoint=i]) == b:', ' total = total + 1', ' return total']) {
|
|
assert.ok(r.source.split('\n').includes(line), `missing: ${line}`);
|
|
}
|
|
assert.ok(!r.source.includes('+='), 'the translator never rewrites total = total + 1');
|
|
});
|
|
|
|
test('the translator does not import or mention the best-practices helper', () => {
|
|
const text = fs.readFileSync(path.join(here, '..', 'src', 'sync', 'pseudo-to-mojo.ts'), 'utf8');
|
|
assert.ok(!/practices/i.test(text), 'src/sync/pseudo-to-mojo.ts refers to the helper');
|
|
});
|
|
|
|
test('every generated source starts with the generated-code header and has a line map that fits', () => {
|
|
for (const p of programs()) {
|
|
const r = pseudoToMojo(p.pseudo, { call: p.call });
|
|
if ('unsupported' in r) continue;
|
|
const lines = r.source.replace(/\n$/, '').split('\n');
|
|
assert.equal(lines[0], GENERATED_HEADER, p.id);
|
|
assert.equal(r.map.length, lines.length, `${p.id}: one map entry per line`);
|
|
assert.equal(r.map[0], null, p.id);
|
|
const pseudoLines = p.pseudo.split('\n').length;
|
|
for (const m of r.map) assert.ok(m === null || (Number.isInteger(m) && m >= 1 && m <= pseudoLines), `${p.id}: map entry ${m}`);
|
|
}
|
|
});
|
|
|
|
test('the map links Mojo lines to the pseudo lines they came from', () => {
|
|
const ex = EXERCISES.find((e) => e.id === 'count-base');
|
|
const r = pseudoToMojo(ex.sources.pseudo, { call: ex.call });
|
|
const lines = r.source.split('\n');
|
|
const pseudo = ex.sources.pseudo.split('\n');
|
|
const at = lines.findIndex((l) => l.includes('total = total + 1'));
|
|
assert.ok(pseudo[r.map[at] - 1].includes('Total <- Total + 1'), pseudo[r.map[at] - 1]);
|
|
});
|
|
|
|
test('grounding: every standard-library name the translator writes is in the harvested index, with the module it imports from', () => {
|
|
const structs = MOJO_STD_STRUCTS;
|
|
const exported = (n) => MOJO_STD_EXPORTS[n] ?? (structs[n] ? 'std' : undefined);
|
|
for (const [name, mod] of Object.entries(USED_STDLIB)) assert.equal(MOJO_STD_EXPORTS[name], mod, `${name} should come from ${mod}`);
|
|
// names the index leaves out are named here, with why: Float64 is a SIMD alias, abs is exported from two modules
|
|
const NOT_INDEXED = { Float64: 'an alias of SIMD', abs: 'exported from two modules, so the index leaves it out', Int: 'a builtin type' };
|
|
for (const name of USED_PRELUDE) assert.ok(exported(name) || NOT_INDEXED[name], `${name} is not in the harvested index`);
|
|
});
|
|
|
|
test('every import in a generated source is one the translator knows, and no import is unused', () => {
|
|
for (const p of programs()) {
|
|
const r = pseudoToMojo(p.pseudo, { call: p.call });
|
|
if ('unsupported' in r) continue;
|
|
const body = r.source.split('\n').filter((l) => !l.startsWith('from ')).join('\n');
|
|
for (const m of r.source.matchAll(/^from (\S+) import (.+)$/gm)) {
|
|
for (const name of m[2].split(', ')) {
|
|
assert.equal(USED_STDLIB[name], m[1], `${p.id}: ${m[0]}`);
|
|
assert.ok(new RegExp(`\\b${name}\\b`).test(body), `${p.id}: ${name} is imported and never used`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
test('main is written from the call: literals follow the parameter types (TRUE, character literals, floats, lists)', () => {
|
|
const pseudo = `FUNCTION F(B : BOOL, C : CHAR, X : FLOAT, L : LIST OF INTEGER) RETURNS BOOL
|
|
RETURN B AND C == 'A' AND X > 0.5 AND LENGTH(L) > 1
|
|
ENDFUNCTION
|
|
`;
|
|
const r = pseudoToMojo(pseudo, { call: "F(TRUE, 'A', 1, [3, 4])" });
|
|
assert.ok(r.source.includes(' print(f(True, "A", 1.0, List[Int](3, 4)))'), r.source);
|
|
assert.equal(checkMojo(r.source).diagnostics.filter((d) => d.severity === 'error').length, 0);
|
|
const run = runMojo(checkMojo(r.source).module, r.source, {});
|
|
assert.equal(run.stdout, 'True\n');
|
|
});
|
|
|
|
test('main follows the pseudo\'s own lines, and a procedure call is not printed', () => {
|
|
const r = pseudoToMojo('PROCEDURE SHOW(N : INTEGER)\n OUTPUT N\nENDPROCEDURE\n', { call: 'SHOW(4)' });
|
|
assert.ok(r.source.includes('def main():\n show(4)\n'), r.source);
|
|
const none = pseudoToMojo('FUNCTION F(N : INTEGER) RETURNS INTEGER\n RETURN N\nENDFUNCTION\n');
|
|
assert.ok(!none.source.includes('def main'), 'with no call and no lines of its own there is nothing to run');
|
|
});
|
|
|
|
test('raises is inferred through dictionary reads and through callers, and nothing else raises', () => {
|
|
const pseudo = `FUNCTION GET(M : HASHMAP OF STRING : INTEGER, K : STRING) RETURNS INTEGER
|
|
RETURN M[K]
|
|
ENDFUNCTION
|
|
FUNCTION TWICE(M : HASHMAP OF STRING : INTEGER, K : STRING) RETURNS INTEGER
|
|
RETURN GET(M, K) * 2
|
|
ENDFUNCTION
|
|
FUNCTION PLAIN(N : INTEGER) RETURNS INTEGER
|
|
RETURN N + 1
|
|
ENDFUNCTION
|
|
`;
|
|
const r = pseudoToMojo(pseudo, { call: null });
|
|
assert.ok(r.source.includes('def get(m: Dict[String, Int], k: String) raises -> Int:'), r.source);
|
|
assert.ok(r.source.includes('def twice(m: Dict[String, Int], k: String) raises -> Int:'), r.source);
|
|
assert.ok(r.source.includes('def plain(n: Int) -> Int:'), r.source);
|
|
const withMain = pseudoToMojo(pseudo + 'OUTPUT PLAIN(1)\n');
|
|
assert.ok(withMain.source.includes('def main():'), 'main does not raise when nothing it calls does');
|
|
const raising = pseudoToMojo(pseudo + 'DECLARE M : HASHMAP OF STRING : INTEGER\nM["a"] <- 1\nOUTPUT TWICE(M, "a")\n');
|
|
assert.ok(raising.source.includes('def main() raises:'), raising.source);
|
|
});
|
|
|
|
test('a set needs its import, and the import comes from the harvested module', () => {
|
|
const r = pseudoToMojo('TYPE Bases = SET OF CHAR\nDEFINE Purines (\'A\', \'G\') : Bases\nOUTPUT \'A\' IN Purines\n');
|
|
assert.ok(r.source.includes('from std.collections import Set'), r.source);
|
|
assert.equal(checkMojo(r.source).diagnostics.filter((d) => d.severity === 'error').length, 0);
|
|
});
|
|
|
|
test('what has no faithful Mojo becomes a visible raise and a warning, never a guess', () => {
|
|
const r = pseudoToMojo('DECLARE N : FLOAT\nN <- 1.0\nN <- RANDN()\nOUTPUT N\n');
|
|
const gap = r.notes.find((n) => n.id === 'translate-gap');
|
|
assert.ok(gap && gap.severity === 'warning' && gap.line === 3, JSON.stringify(r.notes ?? r));
|
|
assert.ok(r.source.includes('raise Error("not translated: pseudo line 3")'), r.source);
|
|
assert.ok(r.source.includes('def main() raises:'), 'the routine that raises says so');
|
|
assert.equal(checkMojo(r.source).diagnostics.filter((d) => d.severity === 'error').length, 0, 'the result still checks');
|
|
});
|
|
|
|
test('float literals are not folded the way Mojo folds them: 0.1 + 0.2 stays a Float64 sum', () => {
|
|
const r = pseudoToMojo('OUTPUT 0.1 + 0.2 == 0.3\n');
|
|
assert.ok(r.source.includes('Float64(0.1) + 0.2 == 0.3'), r.source);
|
|
const run = runMojo(checkMojo(r.source).module, r.source, {});
|
|
assert.equal(run.stdout, 'FALSE\n');
|
|
});
|
|
|
|
test('quantifiers become loops written before the line that uses them, and agree with the pseudo', () => {
|
|
const src = fs.readFileSync(path.join(corpusDir, '27-quantifiers.pseudo'), 'utf8');
|
|
const r = pseudoToMojo(src);
|
|
assert.ok(/var _all\d+ = True/.test(r.source) && /var _any\d+ = False/.test(r.source) && /var _sum\d+ = 0/.test(r.source), r.source);
|
|
assert.equal(verdicts.get('27-quantifiers.pseudo')?.verdict, 'agree');
|
|
});
|
|
|
|
test('a quantifier inside a loop condition is a gap, not a wrong answer', () => {
|
|
const r = pseudoToMojo('DECLARE L : LIST OF INTEGER\nL <- [1, 2]\nWHILE EXISTS K IN [0, LENGTH(L)) : L[K] > 5\n L[0] <- 9\nENDWHILE\n');
|
|
assert.ok(r.notes.some((n) => n.id === 'translate-gap'), JSON.stringify(r.notes));
|
|
});
|