Pseudo could say what a procedure computes only up to INTEGER and FLOAT, so it could not state what a Mojo or Python program with Int32, UInt8 or Float32 values will compute, and it had no words for rounding itself. - lang/parse: INT8..INT64, UINT8..UINT64, FLOAT32, FLOAT64 as types (INTEGER or FLOAT with a width, so every "whole number" rule accepts them); conversions written as Mojo writes them, INT32(X), FLOAT32(X); 1_000_000, 0xFF and 0b1010 literals; a type name as an argument (MAX_VALUE(INT8)); the USE line (USE IEEE now, library modules next). - check: widths and precisions never mix silently (mixed-width, mixed-precision); a literal takes the type of the sized value beside it, as in Mojo, and one that does not fit is an error before any run (literal-range); typing for every new built-in. - interp: a sized result, store, parameter, RETURN or conversion that does not fit stops the run (kind overflow), WRAP(X, T) wraps on purpose; FLOAT32 results are rounded to single precision; USE IEEE lets NaN and infinities flow. - numeric.js: exact helpers: FMA rounded once, EXACT(X) with every digit a FLOAT holds, ULP and NEXT_AFTER for both precisions, bit operations in two's complement. - Built-ins: ASIN ACOS ATAN SINH COSH TANH HYPOT POW CBRT EXPM1 LOG1P E TRUNC SIGN COPYSIGN CLAMP FMA IS_NAN IS_INF IS_FINITE INF NAN ULP NEXT_AFTER IS_CLOSE EXACT MAX_VALUE MIN_VALUE EPSILON GCD LCM BIT_AND BIT_OR BIT_XOR BIT_NOT SHIFT_LEFT SHIFT_RIGHT WRAP. They stay usable as names (a variable E, a FUNCTION GCD): the program's own wins. - vcgen: an overflow obligation on every sized result, then the range as a fact (also for sized parameters and loop-cut variables); FLOAT32 arithmetic as its own uninterpreted functions, constants rounded exactly, TOFLOAT32(v) otherwise; argument obligations for SQRT, the logarithms, ASIN/ACOS, LOG1P, CLAMP and the shifts; nothing proved under USE IEEE. - testing: the fuzzer tries the edges of a sized type and generates FLOAT32 values. - pseudo-to-mojo: Int8..Float32, conversions, the new built-ins through std.math (each name in the harvested index), a note where Mojo wraps. - Tests: numeric.test.mjs; corpus 49-52; prover fixtures int8-overflow, float32-store, ieee-nan; the reference documents every new form. Gate: 324 pass (core). New Mojo uses std.math names the interpreter has not been verified on (listed in sync-mojo's KNOWN_GAPS); they need pixi run mojo-verify on the network before the interpreter runs them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
131 lines
8.5 KiB
JavaScript
131 lines
8.5 KiB
JavaScript
// The reference is only trustworthy if its examples run through the real parsers.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { REFERENCE, PSEUDO_REF, LINGO_REF, SPECO_REF, ASM_REF, MATHO_REF, explain, SPECO_SYMBOLS } from '../dist/common/reference.js';
|
|
import { parseMatho } from '../dist/services/matho.js';
|
|
import { studyOf } from '../dist/services/pseudo.js';
|
|
import { readLingo } from '../dist/services/lingo.js';
|
|
import { parseSpeco, toAscii, toMath } from '../dist/services/speco.js';
|
|
import { parseAsm } from '../dist/services/asm.js';
|
|
import { KEYWORDS, BUILTINS, SOFT_BUILTINS } from '../dist/engines/pseudo/lang.js';
|
|
import { OPS } from '../dist/engines/asm86/interp.js';
|
|
|
|
test('every pseudocode statement example parses and checks', () => {
|
|
const sec = PSEUDO_REF.sections.find((s) => s.id === 'pseudo-statements');
|
|
for (const e of sec.entries) {
|
|
const st = studyOf(e.example);
|
|
const errs = st.diagnostics.filter((d) => d.severity === 'error');
|
|
assert.equal(errs.length, 0, `${e.term}: ${errs.map((d) => `L${d.line} ${d.message}`).join(' | ')}`);
|
|
}
|
|
});
|
|
|
|
test('every keyword in the engine has a meaning in the reference, and vice versa', () => {
|
|
const sec = PSEUDO_REF.sections.find((s) => s.id === 'pseudo-keywords');
|
|
const listed = new Set(sec.entries.map((e) => e.term));
|
|
for (const k of KEYWORDS) assert.ok(listed.has(k), `keyword ${k} is missing from the reference`);
|
|
for (const e of sec.entries) assert.ok(e.meaning.length > 10, `${e.term} has no meaning`);
|
|
for (const b of Object.keys(BUILTINS)) assert.ok(explain('pseudo', b), `built-in ${b} has no hover`);
|
|
});
|
|
|
|
test('every lingo sentence example reads (inside a minimal routine where needed)', () => {
|
|
const failures = [];
|
|
// kinds for every name the examples mention, so a fragment reads the same way it does on the page
|
|
const kinds = 'T is a text. P is a text. S is a text. w is a text. A is a whole number. Score is a whole number.';
|
|
const setup = [
|
|
'Start with Count at 0.', 'Start with Best at 0.', 'Start with Run at 0.', 'Start with Left at 3.', 'Start with window at "AC".',
|
|
'Start with an empty list called Starts.', 'Start with an empty tally called Counts.', 'Start with an empty text called R.',
|
|
];
|
|
const defs = "The complement of b is 'T' when b is 'A', and 'N' otherwise.";
|
|
for (const sec of LINGO_REF.sections.filter((s) => s.id.startsWith('lingo-forms'))) {
|
|
for (const e of sec.entries) {
|
|
if (!e.example) continue;
|
|
const ex = e.example.trim();
|
|
const examples = ex.includes(' ') && !/^To /.test(ex) && !/ when /.test(ex) ? ex.split(/\s{2,}/) : [ex];
|
|
for (const one of examples) {
|
|
let src;
|
|
const head = 'To test T, P, S, w, A, B and Score:';
|
|
const pre = setup.map((l) => ' ' + l).join('\n');
|
|
if (/^The answer is/.test(one)) src = `${head}\n${pre}\n Start with i at 0.\n ${one}\n\n${kinds}`;
|
|
else if (/^To /.test(one)) src = `${one}\n${pre}\n The answer is Count.\n\n${kinds}`;
|
|
else if (/ when /.test(one) || /^The .* is /.test(one)) src = `To test P, T, S and b:\n Start with i at 0.\n If b is 'A', add 1 to i.\n The answer is the length of T plus the length of P plus the length of S plus i.\n\n${one}${/[.:]$/.test(one) ? '' : '.'}\n\nP is a text. T is a text. S is a text. b is a letter.`;
|
|
else if (/^(For|Repeat)/.test(one)) src = `${head}\n${pre}\n${/^For (each|every) .*\bi\b/.test(one) ? '' : ' Start with i at 0.\n'} ${one}\n Add 1 to Count.\n The answer is Count.\n\n${kinds}`;
|
|
else if (/^If /.test(one) && /:$/.test(one)) src = `${head}\n${pre}\n ${one}\n Add 1 to Count.\n The answer is Count.\n\n${kinds}`;
|
|
else if (sec.title === 'Tests') src = `${head}\n${pre}\n For each position i of T:\n Set b to the letter of T at i.\n ${/^If /.test(one) ? one : `If ${one}, add 1 to Count.`}\n The answer is Count.\n\n${kinds}`;
|
|
else if (sec.title === 'Values') src = `${head}\n${pre}\n For each position i of T:\n Set X to ${one}.\n The answer is Count.\n\n${kinds}`;
|
|
else src = `${head}\n${pre}\n Start with i at 0.\n${/\bb\b/.test(one) && !/\bB\b/.test(one) ? ' Set b to the letter of T at i.\n' : ''} ${one}\n The answer is Count.\n\n${/complement/.test(one) ? defs + '\n\n' : ''}${kinds}${/^Swap/.test(one) ? ' B is a whole number.' : ''}`;
|
|
const r = readLingo(src);
|
|
const tolerated = ['pronoun', 'kind-clash', 'unset-read', 'borrowed-input', 'which-letter', 'never-read', 'unreachable'];
|
|
const errs = r.diagnostics.filter((d) => d.severity === 'error' && !tolerated.includes(d.id));
|
|
if (errs.length) failures.push(`${e.term} → "${one}": ${errs.map((d) => d.id + ': ' + d.message.slice(0, 100)).join(' | ')}`);
|
|
}
|
|
}
|
|
}
|
|
assert.deepEqual(failures, []);
|
|
});
|
|
|
|
test('every lingo ambiguity example raises exactly the question it documents', () => {
|
|
const sec = LINGO_REF.sections.find((s) => s.id === 'lingo-questions');
|
|
for (const e of sec.entries) {
|
|
const r = readLingo(e.example);
|
|
assert.ok(r.diagnostics.some((d) => d.id === e.term), `${e.term}: got ${r.diagnostics.map((d) => d.id).join(', ')}`);
|
|
}
|
|
});
|
|
|
|
test('every speco example parses, and the symbol table round-trips', () => {
|
|
const sec = SPECO_REF.sections.find((s) => s.id === 'speco-forms');
|
|
for (const e of sec.entries) {
|
|
const m = parseSpeco(e.example);
|
|
assert.ok(m.ok, `${e.term}: ${m.diagnostics.map((d) => d.message).join(' | ')}`);
|
|
}
|
|
for (const s of SPECO_SYMBOLS) {
|
|
if (s.math.length !== 1) continue;
|
|
assert.equal(toAscii(`A ${s.math} B`), `A ${s.ascii} B`);
|
|
assert.equal(toMath(`A ${s.ascii} B`), `A ${s.math} B`);
|
|
}
|
|
});
|
|
|
|
test('every instruction has a gloss and a hover; setup examples parse', () => {
|
|
for (const op of Object.keys(OPS)) assert.ok(explain('asm', op)?.body, `${op} has no gloss`);
|
|
for (const e of ASM_REF.sections.find((s) => s.id === 'asm-registers').entries) assert.ok(explain('asm', e.term), e.term);
|
|
assert.ok(parseAsm(' mov rax, [rbx]\n ret\n').ok);
|
|
assert.ok(REFERENCE.length === 5);
|
|
});
|
|
|
|
test('every pseudo idiom runs and prints what its note says', async () => {
|
|
const { runPseudo } = await import('../dist/services/pseudo.js');
|
|
const { KEYWORDS: KW, BUILTINS: BI, CONTEXTUAL } = await import('../dist/engines/pseudo/lang.js');
|
|
const sec = PSEUDO_REF.sections.find((s) => s.id === 'pseudo-idioms');
|
|
assert.ok(sec.entries.length >= 8);
|
|
for (const e of sec.entries) {
|
|
const st = studyOf(e.example);
|
|
const errs = st.diagnostics.filter((d) => d.severity === 'error');
|
|
assert.equal(errs.length, 0, `${e.term}: ${errs.map((d) => `L${d.line} ${d.message}`).join(' | ')}`);
|
|
const tr = runPseudo(st, { input: [], maxSteps: 200000 });
|
|
assert.equal(tr.error, null, `${e.term}: ${tr.error?.message}`);
|
|
const out = tr.output.filter((l) => !/^\w+ returned /.test(l));
|
|
assert.deepEqual(out, [e.note], e.term);
|
|
}
|
|
const reserved = PSEUDO_REF.sections.find((s) => s.id === 'pseudo-reserved');
|
|
const words = new Set(reserved.entries.map((e) => e.term));
|
|
for (const k of KW) assert.ok(words.has(k), `reserved list misses keyword ${k}`);
|
|
for (const k of Object.keys(CONTEXTUAL)) assert.ok(words.has(k), `reserved list misses ${k}`);
|
|
// the built-ins added for numerical work stay usable as names (a variable E, a FUNCTION GCD), so they are not listed
|
|
for (const k of Object.keys(BI)) assert.ok(SOFT_BUILTINS.has(k) ? !words.has(k) : words.has(k), SOFT_BUILTINS.has(k) ? `${k} can be a name, so it is not reserved` : `reserved list misses built-in ${k}`);
|
|
});
|
|
|
|
test('every matho example translates to pseudo that checks, and every refusal is refused', () => {
|
|
const forms = MATHO_REF.sections.find((s) => s.id === 'matho-forms');
|
|
for (const e of forms.entries) {
|
|
const r = parseMatho(e.example);
|
|
const errs = r.diagnostics.filter((d) => d.severity === 'error');
|
|
assert.ok(r.ok, `${e.term}: ${errs.map((d) => `L${d.line} ${d.id}: ${d.message}`).join(' | ')}\n${r.program.pseudo}`);
|
|
const st = studyOf(r.program.pseudo);
|
|
assert.ok(st.ok, `${e.term}: the pseudo does not check: ${st.diagnostics.filter((d) => d.severity === 'error').map((d) => d.message).join(' | ')}`);
|
|
}
|
|
for (const src of ['y = \\int_0^1 x dx', 's = \\sum_{i=0}^{\\infty} x_i', 'y = \\lim_{x \\to 0} x', 'y = \\partial f', 'y = a \\pm b', 'a = b = c']) {
|
|
const r = parseMatho(src);
|
|
assert.equal(r.ok, false, `${src} should be refused`);
|
|
assert.ok(r.diagnostics.some((d) => d.severity === 'error' && /matho-(refused|pm|chain)/.test(d.id)), src);
|
|
}
|
|
});
|