Files
pplus-core/src/sync/pseudo-to-mojo.ts
T
alexmandClaude 7ddc628597 Add USE and pin pplus-library: routines verified once, used by name
Routines that many programs need (a mean, a gap penalty, the
Lennard-Jones potential, the minimum image convention) were rewritten
and re-verified each time, and there was no way to open one and see
exactly what it does. They now live in pplus-library, pinned here as
the submodule library/, and a program brings them in with USE.

- USE module / USE module.Routine (pseudo-study resolveUses): each
  routine is studied once in its own file (its own USE lines resolved
  the same way, cycles refused) and handed to the checker as a library
  routine; unknown-library, unknown-routine, library-clash, use-place.
- A run steps over a library routine (one step at the call, one at the
  return, none of its lines); a broken contract is reported at the call,
  naming the routine. The prover uses its REQUIRE and ENSURE at the
  call and does not prove it again; it is not a unit of the program.
- pseudo-to-mojo writes each library routine the program calls once,
  dependencies first, labeled as coming from the library.
- src/library: the registry USE reads, generated from library/
  (scripts/library.mjs emit), so the site needs no files at run time.
- scripts/library.mjs check: every routine at every level: structure,
  cases, prover, fuzzer, generated Mojo, each reference implementation
  (CPython; cc at -O0 and -O2; core's Mojo interpreter; the pinned
  compiler's stored answer) held to the pseudo's results, and the Dafny
  proof with the pinned Dafny. Writes library/status.json and STATUS.md.
  scripts/library_godbolt.py stores the compiler's answers (network).
- pixi tasks library-check, library-emit, library-verify-mojo,
  library-harness; CI checks out the submodule and runs library-check.
- Tests: tests/library.test.mjs, corpus 53-library; docs/library.md and
  a library section in trust.md.

Gate: 332 pass; library-check: no failing check (16 routines; the Mojo
references are unverified until library-verify-mojo runs on the network).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
2026-10-05 12:06:41 +00:00

1074 lines
57 KiB
TypeScript

/**
* Pseudo to Mojo 1.1.0: the one translator in the sync model that only goes one way.
*
* This is an app-owned port of the Mojo half of src/engines/pseudo/translate.js
* (the engine file is left untouched; this fork is where the app's Mojo is
* decided). What changed from the engine's version:
*
* - it writes `def main()` itself, from the program's own lines or from the
* call the student is running (COUNT_BASE('A', "GATTACA") becomes
* print(count_base("A", "GATTACA")));
* - `raises` is inferred, transitively, so the result passes the checker;
* - imports come from the harvested standard-library index;
* - it never writes a construct the interpreter declines when a verified
* spelling exists (a fixed-length ARRAY is an append loop, not List(length=));
* - it never invents Mojo. What has no faithful spelling (a statistic the
* standard library lacks, a blank to fill in) becomes
* `raise Error("not translated: ...")` with a diagnostic, never a value
* that looks right and is not;
* - FORALL, EXISTS, SUM, set-builder, KEYS, SORTED, SPLIT, FILL and the
* other built-ins with no one-line spelling become a short loop written
* just before the statement that uses them.
*
* The translation stays literal on purpose (`var n: Int` then `n = ...`,
* `total = total + 1`, an index loop over codepoints). Idiomatic rewrites are
* left to the optional Mojo helper under src/mojo/, so a student can see the
* difference. Nothing here may import that helper.
*/
import { studyPseudo as study } from '../services/pseudo-study.js';
import { sourceOf, parseExpression } from '../engines/pseudo/parse.js';
import { walkStatements, walkExpr, statementExprs, rootName } from '../engines/pseudo/analyze.js';
import { toDiagnostic } from '../services/pseudo.js';
import { MOJO_STD_EXPORTS } from '../mojo/generated/stdlib.js';
import type { Diagnostic } from '../common/types.js';
import type { LineMap } from './types.js';
import { GENERATED_HEADER } from './header.js';
export { GENERATED_HEADER };
export interface MojoOptions {
/** The call to run, such as COUNT_BASE('A', "GATTACA"); becomes the body of `main` when the pseudo has no lines of its own. */
call?: string | null;
/** Internal: write the definitions only, no imports and no main (a library routine). */
defsOnly?: boolean;
/** Internal: the library routines' Mojo, written before the program's own definitions. */
libraryBlocks?: Array<{ id: string; lines: string[]; imports: string[] }>;
}
export interface MojoResult { source: string; map: LineMap; notes: Diagnostic[] }
/** Every standard-library name the translator can write, with the module it comes from. A test holds each to the harvested index. */
export const USED_STDLIB: Readonly<Record<string, string>> = {
Set: 'std.collections', sort: 'std.builtin.sort',
sqrt: 'std.math', exp: 'std.math', log: 'std.math', log2: 'std.math', log10: 'std.math',
sin: 'std.math', cos: 'std.math', tan: 'std.math', atan2: 'std.math', pi: 'std.math',
floor: 'std.math', ceil: 'std.math', comb: 'std.math',
asin: 'std.math', acos: 'std.math', atan: 'std.math', sinh: 'std.math', cosh: 'std.math', tanh: 'std.math',
hypot: 'std.math', cbrt: 'std.math', expm1: 'std.math', log1p: 'std.math', trunc: 'std.math', copysign: 'std.math',
fma: 'std.math', isnan: 'std.math', isinf: 'std.math', isfinite: 'std.math', inf: 'std.math', nan: 'std.math',
ulp: 'std.math', nextafter: 'std.math', gcd: 'std.math', lcm: 'std.math',
random_float64: 'std.random', random_si64: 'std.random',
};
/** Names the translator writes that Mojo provides without an import. */
export const USED_PRELUDE: readonly string[] = ['Int', 'Float64', 'String', 'Bool', 'List', 'Dict', 'print', 'range', 'len', 'min', 'max', 'abs', 'round', 'input', 'atol', 'atof', 'chr', 'ord', 'Error',
'Int8', 'Int16', 'Int32', 'Int64', 'UInt8', 'UInt16', 'UInt32', 'UInt64', 'Float32', 'DType'];
/** The Mojo type for a pseudo number type: INT8 is Int8, FLOAT32 is Float32, INTEGER is Int, FLOAT and FLOAT64 are Float64. */
export function mojoNumber(t: any): string | null {
if (!t) return null;
if (t.k === 'INTEGER') return t.bits ? `${t.signed ? 'Int' : 'UInt'}${t.bits}` : 'Int';
if (t.k === 'FLOAT') return t.bits === 32 ? 'Float32' : 'Float64';
return null;
}
const isSized = (t: any): boolean => !!t && ((t.k === 'INTEGER' && !!t.bits) || (t.k === 'FLOAT' && t.bits === 32));
const up = (s: unknown): string => String(s).toUpperCase();
/** GCCount -> gc_count, MaxOf -> max_of, I -> i, COUNT_BASE -> count_base. */
export function snake(name: string): string {
if (/^[A-Z0-9_]+$/.test(name)) return name.toLowerCase();
return name
.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
.replace(/([a-z0-9])([A-Z])/g, '$1_$2')
.toLowerCase();
}
/** Words a pseudo name must not become in Mojo: keywords, builtins the translation itself calls, and imported names. */
const RESERVED = new Set([
'def', 'fn', 'struct', 'trait', 'comptime', 'alias', 'var', 'ref', 'mut', 'out', 'read', 'owned', 'inout', 'deinit', 'raises', 'raise', 'try', 'except', 'finally', 'with', 'as', 'import', 'from',
'and', 'or', 'not', 'in', 'is', 'if', 'elif', 'else', 'for', 'while', 'break', 'continue', 'return', 'pass', 'del', 'assert', 'class', 'lambda', 'global', 'yield', 'match', 'case', 'self',
'len', 'min', 'max', 'abs', 'round', 'print', 'range', 'input', 'sum', 'type', 'list', 'str', 'int', 'float', 'set', 'dict', 'chr', 'ord', 'pow', 'sort', 'sorted', 'copy', 'main',
'atol', 'atof', 'floor', 'ceil', 'sqrt', 'exp', 'log', 'log2', 'log10', 'sin', 'cos', 'tan', 'atan2', 'pi', 'comb', 'true', 'false', 'none',
'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64', 'float32', 'float64', 'dtype',
...Object.keys(USED_STDLIB),
]);
const COLLECTIONS = new Set(['LIST', 'ARRAY', 'HASHMAP', 'SET', 'RECORD']);
const isCollection = (t: any): boolean => !!t && COLLECTIONS.has(t.k);
/** A statement or expression with no faithful Mojo spelling. Caught at the statement, which becomes a visible `raise`. */
class Gap extends Error { }
interface Line { text: string; from: number | null }
interface Pending { d: number; text: string }
interface Ctx { sub: any | null; owner: string }
/** An expression made only of numeric literals: Mojo folds these at compile time. */
function litOnly(e: any): boolean {
if (!e) return false;
if (e.kind === 'Num') return true;
if (e.kind === 'Unary') return e.op !== 'NOT' && litOnly(e.arg);
if (e.kind === 'Binary') return ['+', '-', '*'].includes(e.op) && litOnly(e.left) && litOnly(e.right);
return false;
}
function hasFloatLit(e: any): boolean {
if (!e) return false;
if (e.kind === 'Num') return !!e.float || /[.e]/.test(String(e.value));
return hasFloatLit(e.arg) || hasFloatLit(e.left) || hasFloatLit(e.right);
}
function key(name: string): string { return up(name); }
/* ------------------------------------------------------------------ */
/* Which routines raise */
/* ------------------------------------------------------------------ */
/** Does a statement list contain something that raises in Mojo? `raising` is the set of subroutines already known to. */
function bodyRaises(body: any[], raising: Set<string>): boolean {
let hit = false;
const exprHit = (e: any) => {
walkExpr(e, (x: any) => {
if (hit) return false;
if (x.kind === 'Index' && x.target?.type?.k === 'HASHMAP') hit = true;
if (x.kind === 'CallExpr') {
if (!x.builtin && raising.has(key(x.name))) hit = true;
if (x.builtin === 'TO_INTEGER' || x.builtin === 'TO_FLOAT') hit = true;
}
return undefined;
});
};
walkStatements(body, (s: any) => {
if (hit) return false;
if (s.kind === 'Input' || s.kind === 'Assert' || s.kind === 'BlankStmt') hit = true;
if (s.kind === 'Call' && raising.has(key(s.name))) hit = true;
if (s.kind === 'BuiltinCall' && s.name === 'DELETE') hit = true;
for (const e of statementExprs(s)) exprHit(e);
return undefined;
});
return hit;
}
function inferRaising(program: any, seed: Iterable<string>): Set<string> {
const raising = new Set<string>(seed);
let changed = true;
while (changed) {
changed = false;
for (const sub of program.subs.values()) {
const k = key(sub.name);
if (!raising.has(k) && bodyRaises(sub.node.body, raising)) { raising.add(k); changed = true; }
}
}
return raising;
}
/* ------------------------------------------------------------------ */
/* The translator */
/* ------------------------------------------------------------------ */
class Gen {
out: Line[] = [];
pending: Pending[] = [];
notes = new Map<string, Diagnostic>();
gaps: Diagnostic[] = [];
gapOwners = new Set<string>();
imports = new Set<string>();
names = new Map<string, string>();
commentsByLine = new Map<number, any>();
usedComments = new Set<number>();
hoistOK = true;
temp = 0;
curLine = 1;
srcLines: string[];
varParams = new Map<string, boolean[]>();
/** The type an empty list literal takes from where it is going (an assignment's target, a parameter, a return type). */
hint: any = null;
temps = new Set<string>();
/** Set while translating a call's own text (the argument literals), which has no type annotations. */
constructor(private program: any, private source: string, private raising: Set<string>, private opts: MojoOptions) {
for (const c of program.comments || []) this.commentsByLine.set(c.line, c);
this.srcLines = source.split('\n');
for (const sub of [...program.subs.values(), ...(program.libs?.values() ?? [])]) {
const changed = this.changedIn(sub.node.body);
const assigned = this.assignedIn(sub.node.body);
this.varParams.set(key(sub.name), sub.params.map((p: any) => p.mode !== 'BYREF' && ((changed.has(up(p.name)) && isCollection(p.type)) || assigned.has(up(p.name)))));
}
}
/* ---------- bookkeeping ---------- */
changedIn(body: any[]): Set<string> {
const out = new Set<string>();
walkStatements(body, (x: any) => {
if (x.kind === 'BuiltinCall' && x.args[0]) { const r = rootName(x.args[0]); if (r) out.add(up(r)); }
if ((x.kind === 'Assign' || x.kind === 'Input') && x.target.kind !== 'Name') { const r = rootName(x.target); if (r) out.add(up(r)); }
if (x.kind === 'Call') x.args.forEach((a: any, i: number) => { if (x.sub?.params?.[i]?.mode === 'BYREF' && a.kind !== 'Name') { const r = rootName(a); if (r) out.add(up(r)); } });
return undefined;
});
return out;
}
/** Names a body gives a new value to directly (X <- ..., INPUT X, a FOR counter). */
assignedIn(body: any[]): Set<string> {
const out = new Set<string>();
walkStatements(body, (x: any) => {
if ((x.kind === 'Assign' || x.kind === 'Input') && x.target.kind === 'Name') out.add(up(x.target.name));
if (x.kind === 'For' || x.kind === 'ForEach') out.add(up(x.var));
return undefined;
});
return out;
}
withHint<T>(t: any, fn: () => T): T {
const saved = this.hint;
this.hint = t;
try { return fn(); } finally { this.hint = saved; }
}
note(id: string, text: string): void {
if (!this.notes.has(id)) this.notes.set(id, { lang: 'mojo', severity: 'note', id: `translate-${id}`, line: this.curLine, message: text });
}
gap(why: string): never { throw new Gap(why); }
need(name: string): void { this.imports.add(name); }
name(n: string): string {
const k = up(n);
const have = this.names.get(k);
if (have) return have;
let s = snake(n);
if (RESERVED.has(s)) s = `${s}_`;
this.names.set(k, s);
return s;
}
constName(n: string): string { return snake(n).toUpperCase(); }
fresh(stem: string): string { const t = `_${stem}${++this.temp}`; this.temps.add(t); return t; }
flush(indent: number, from: number | null): void {
for (const h of this.pending) this.out.push({ text: `${' '.repeat(indent + h.d)}${h.text}`, from });
this.pending = [];
}
emit(indent: number, text: string, from: number | null): void {
this.flush(indent, from);
this.out.push({ text: text ? `${' '.repeat(indent)}${text}` : '', from });
}
hoist(lines: Array<[number, string]>): void {
if (!this.hoistOK) this.gap('a computed value inside a condition that is checked again each time');
for (const [d, text] of lines) this.pending.push({ d, text });
}
leadingComments(line: number, indent: number): void {
for (const [l, c] of this.commentsByLine) {
if (l >= line || this.usedComments.has(l) || !c.standalone) continue;
this.usedComments.add(l);
this.emit(indent, `# ${c.text}`, l);
}
}
trailing(line: number): string {
const c = this.commentsByLine.get(line);
if (!c || c.standalone || this.usedComments.has(line)) return '';
this.usedComments.add(line);
return ` # ${c.text}`;
}
/* ---------- types and defaults ---------- */
type(t: any): string {
if (!t) this.gap('a value whose type is not known');
switch (t.k) {
case 'INTEGER': case 'FLOAT': return mojoNumber(t)!;
case 'CHAR': case 'STRING': return 'String';
case 'BOOL': return 'Bool';
case 'ARRAY': if (t.dims === 2) return `List[List[${this.type(t.of)}]]`; return `List[${this.type(t.of)}]`;
case 'LIST': return `List[${this.type(t.of)}]`;
case 'HASHMAP': return `Dict[${this.type(t.key)}, ${this.type(t.val)}]`;
case 'SET': this.need('Set'); return `Set[${this.type(t.of)}]`;
case 'RECORD': return t.name;
default: return this.gap(`a value of kind ${t.k}`);
}
}
/** What a declared-but-unset value holds: the notation's collections start empty, a record starts with every field at its default. */
defaultOf(t: any): string {
switch (t?.k) {
case 'INTEGER': return '0';
case 'FLOAT': return '0.0';
case 'BOOL': return 'False';
case 'CHAR': case 'STRING': return 'String("")';
case 'LIST': case 'HASHMAP': case 'SET': return `${this.type(t)}()`;
case 'RECORD': return `${t.name}(${t.fieldNames.map((f: string) => this.defaultOf(t.fields.get(up(f)))).join(', ')})`;
default: return this.gap('a value with no default');
}
}
/** A value that would share storage with its source, copied: M <- L gives M its own list. */
copied(e: any, text: string): string {
if (!isCollection(e.type) || !(['Name', 'Field', 'Index'].includes(e.kind) || this.temps.has(text))) return text;
this.note('copy', 'In the notation, assigning or returning a collection gives a separate copy. Mojo spells that .copy(), because Mojo tracks which piece of code owns a value.');
return `${text}.copy()`;
}
/**
* A value going where another number type belongs, converted as the notation converts it: an INTEGER into a
* FLOAT becomes Float64(...) (Float32(...) for a FLOAT32), an INTEGER into a sized type becomes Int32(...), a
* FLOAT32 into a FLOAT becomes Float64(...). A literal needs nothing: Mojo gives it the type it lands in.
*/
widened(target: any, e: any, text: string): string {
if (!target || !e?.type || e.kind === 'Num') return text;
const want = mojoNumber(target); const have = mojoNumber(e.type);
if (!want || !have || want === have) return text;
if (isSized(target) && target.k === 'INTEGER') this.note('sized', 'In the notation, a value that does not fit a sized whole-number type stops the run. In Mojo, Int8 and the other fixed-width types wrap around silently, and a conversion such as Int8(x) keeps only the low bits.');
return `${want}(${text})`;
}
/* ---------- program ---------- */
run(): MojoResult {
const p = this.program;
for (const c of p.constants.values()) {
this.curLine = c.line;
this.leadingComments(c.line, 0);
this.names.set(up(c.name), this.constName(c.name));
this.guarded(null, c.line, () => this.emit(0, `comptime ${this.constName(c.name)} = ${this.expr(c.node.value)}${this.trailing(c.line)}`, c.line));
}
for (const d of p.defines.values()) {
this.curLine = d.line;
this.leadingComments(d.line, 0);
this.guarded(null, d.line, () => {
const vals = d.node.values.map((v: any) => this.expr(v)).join(', ');
this.emit(0, `def ${this.name(d.name)}() -> ${this.type(d.type)}:${this.trailing(d.line)}`, d.line);
this.emit(1, `return ${this.type(d.type)}(${vals})`, d.line);
});
this.note('define', 'A DEFINE set becomes a small function that builds the Set, because Mojo has no global variables; the code calls it where the pseudo names the set.');
this.emit(0, '', null);
this.emit(0, '', null);
}
for (const t of p.types.values()) {
this.curLine = t.node.line;
this.leadingComments(t.node.line, 0);
this.emit(0, '@fieldwise_init', t.node.line);
this.emit(0, `struct ${t.name}(Copyable, Movable):`, t.node.line);
this.note('struct', 'A record becomes a struct with fields. The traits a struct declares (Copyable, Movable) change between Mojo versions.');
for (const f of t.fieldNames) this.guarded(null, t.node.line, () => this.emit(1, `var ${this.name(f)}: ${this.type(t.fields.get(up(f)))}`, t.node.line));
this.emit(0, '', null);
this.emit(0, '', null);
}
for (const b of this.opts.libraryBlocks || []) {
this.emit(0, `# From the Programming+ library: ${b.id} (verified in pplus-library; generated from its pseudo)`, null);
for (const l of b.lines) this.emit(0, l, null);
for (const n of b.imports) this.imports.add(n);
this.emit(0, '', null);
this.emit(0, '', null);
}
for (const sub of p.subs.values()) { this.subroutine(sub); this.emit(0, '', null); this.emit(0, '', null); }
if (this.opts.defsOnly) return this.assemble();
this.mainFunction();
this.leadingComments(Infinity, 0);
return this.assemble();
}
assemble(): MojoResult {
const imports = new Map<string, string[]>();
for (const n of this.imports) {
const mod = USED_STDLIB[n];
if (!mod) continue;
if (!imports.has(mod)) imports.set(mod, []);
imports.get(mod)!.push(n);
}
const head: Line[] = [{ text: GENERATED_HEADER, from: null }];
for (const [mod, names] of [...imports].sort((a, b) => a[0].localeCompare(b[0]))) head.push({ text: `from ${mod} import ${names.sort().join(', ')}`, from: null });
head.push({ text: '', from: null });
const lines = [...head, ...this.out];
while (lines.length && !lines[lines.length - 1].text.trim()) lines.pop();
return { source: lines.map((l) => l.text).join('\n') + '\n', map: lines.map((l) => l.from), notes: [...this.notes.values(), ...this.gaps] };
}
/** Run `fn`; when it finds something with no faithful Mojo, write a visible `raise` in its place. */
guarded(owner: string | null, line: number, fn: () => void, indent = 0): void {
const saved = this.pending.length;
try { fn(); } catch (err) {
if (!(err instanceof Gap)) throw err;
this.pending.length = saved;
const text = (this.srcLines[line - 1] ?? '').trim();
this.gaps.push({ lang: 'mojo', severity: 'warning', id: 'translate-gap', line, message: `Programming+ could not translate this line into Mojo (${err.message}). The generated code stops here with an error instead of guessing.` });
this.emit(indent, `# pseudo line ${line}: ${text}`, line);
this.emit(indent, `raise Error("not translated: pseudo line ${line}")`, line);
this.gapOwners.add(owner ?? 'main');
}
}
subroutine(sub: any): void {
const s = sub.node;
this.curLine = s.line;
this.leadingComments(s.line, 0);
const k = key(sub.name);
const flags = this.varParams.get(k) || [];
let header = '';
try {
const params = sub.params.map((p: any, i: number) => {
const n = this.name(p.name);
if (p.mode === 'BYREF') { this.note('mut', 'BYREF becomes the mut argument convention, which lets the function change the caller\'s variable.'); return `mut ${n}: ${this.type(p.type)}`; }
if (flags[i]) { this.note('var-param', 'A parameter the procedure gives a new value to or changes is declared var, so the function owns a copy it may change; for a collection the caller passes .copy().'); return `var ${n}: ${this.type(p.type)}`; }
return `${n}: ${this.type(p.type)}`;
}).join(', ');
const ret = s.kind === 'Function' ? ` -> ${this.type(sub.returns)}` : '';
header = `def ${this.name(sub.name)}(${params})${this.raising.has(k) ? ' raises' : ''}${ret}:`;
} catch (err) {
if (!(err instanceof Gap)) throw err;
header = `def ${this.name(sub.name)}() raises:`;
this.gaps.push({ lang: 'mojo', severity: 'warning', id: 'translate-gap', line: s.line, message: `Programming+ could not write this routine's signature in Mojo (${err.message}).` });
this.gapOwners.add(k);
this.emit(0, `${header}${this.trailing(s.line)}`, s.line);
this.emit(1, `raise Error("not translated: pseudo line ${s.line}")`, s.line);
return;
}
this.emit(0, `${header}${this.trailing(s.line)}`, s.line);
for (const r of sub.requires) this.emit(1, `# REQUIRE ${sourceOf(r.expr)}`, r.line);
for (const e of sub.ensures) this.emit(1, `# ENSURE ${sourceOf(e.expr)}`, e.line);
const before = this.out.length;
this.block(s.body, 1, { sub, owner: k });
if (this.out.length === before) this.emit(1, 'pass', s.line);
}
/** `def main()`: the program's own lines, then the call the student is running. */
mainFunction(): void {
const p = this.program;
const body = p.main.body;
const callText = (this.opts.call || '').trim();
const mainRaises = this.raising.has('MAIN');
if (!body.length && !callText) return;
this.emit(0, `def main()${mainRaises ? ' raises' : ''}:`, body[0]?.line ?? null);
const before = this.out.length;
if (body.length) this.block(body, 1, { sub: null, owner: 'main' });
if (callText) this.callLine(callText, 1);
if (this.out.length === before) this.emit(1, 'pass', null);
}
/** print(f(args)): the arguments are literals in the call's own text, written for the parameter types. */
callLine(text: string, d: number): void {
this.guarded('main', 1, () => {
const parsed: any = parseExpression(text);
if (parsed.diags.some((x: any) => x.severity === 'error') || parsed.expr.kind !== 'CallExpr') this.gap('the call is not a call');
const call = parsed.expr;
const sub = this.program.subs.get(up(call.name));
if (!sub || sub.params.length !== call.args.length) this.gap('the call does not match a routine');
const flags = this.varParams.get(key(sub.name)) || [];
const args = call.args.map((a: any, i: number) => this.literal(a, sub.params[i].type, flags[i]));
const expr = `${this.name(sub.name)}(${args.join(', ')})`;
if (sub.kind === 'Function') this.emit(d, `print(${expr})`, null);
else this.emit(d, expr, null);
}, d);
}
/** A literal argument, in the Mojo that fits its parameter. */
literal(e: any, t: any, owned = false): string {
switch (e.kind) {
case 'Num': { const s = String(e.value); return t?.k === 'FLOAT' && !/[.e]/.test(s) ? `${s}.0` : s; }
case 'Str': case 'Char': return JSON.stringify(e.value);
case 'Bool': return e.value ? 'True' : 'False';
case 'Unary': if (e.op === '-') return `-${this.literal(e.arg, t)}`; break;
case 'ListLit': return `${this.type(t)}(${e.items.map((x: any) => this.literal(x, t?.of)).join(', ')})`;
case 'SetLit': this.need('Set'); return `${this.type(t)}(${e.items.map((x: any) => this.literal(x, t?.of)).join(', ')})`;
default: break;
}
void owned;
return this.gap(`the argument ${sourceOf(e)}`);
}
block(body: any[], d: number, ctx: Ctx): void {
const before = this.out.length;
for (const s of body) this.stmt(s, d, ctx);
if (this.out.length === before) this.emit(d, 'pass', null);
}
stmt(s: any, d: number, ctx: Ctx): void {
this.curLine = s.line ?? this.curLine;
this.leadingComments(s.line, d);
this.guarded(ctx.owner, s.line, () => this.stmtBody(s, d, ctx), d);
}
/* ---------- statements ---------- */
stmtBody(s: any, d: number, ctx: Ctx): void {
const tr = () => this.trailing(s.line);
switch (s.kind) {
case 'Declare': {
const t = s.resolved;
// DECLARE x : T <- value (one line in the pseudo) is one line in Mojo too: var x: T = value
if (s.init && s.names.length === 1 && t.k !== 'ARRAY' && t.k !== 'RECORD') {
const a = s.init;
const value = this.withHint(a.target.type, () => this.expr(a.value));
const typed = ['LIST', 'HASHMAP', 'SET'].includes(t.k) ? '' : `: ${this.type(t)}`;
this.emit(d, `var ${this.name(s.names[0].name)}${typed} = ${this.widened(a.target.type, a.value, this.copied(a.value, value))}${tr()}`, s.line);
a.mergedIntoDeclare = true;
return;
}
for (const n of s.names) {
const v = this.name(n.name);
if (t.k === 'ARRAY') { this.arrayDecl(v, t, d, s.line); continue; }
if (['LIST', 'HASHMAP', 'SET'].includes(t.k) || t.k === 'RECORD') this.emit(d, `var ${v} = ${this.defaultOf(t)}${tr()}`, s.line);
else this.emit(d, `var ${v}: ${this.type(t)}${tr()}`, s.line);
if (t.k === 'RECORD') this.note('record-init', 'A struct in Mojo is created with a value for every field at once; the translation starts every field at its default, and the pseudo\'s field assignments change them afterwards.');
}
return;
}
case 'Assign': {
if (s.mergedIntoDeclare) return;
const value = this.withHint(s.target.type, () => this.expr(s.value));
this.emit(d, `${this.lhs(s.target)} = ${this.widened(s.target.type, s.value, this.copied(s.value, value))}${tr()}`, s.line);
return;
}
case 'Input': {
const t = s.target.type;
const read = 'input()';
const conv = t?.k === 'INTEGER' ? `atol(${read})` : t?.k === 'FLOAT' ? `atof(${read})` : t?.k === 'BOOL' ? `${read} == "TRUE"` : read;
this.emit(d, `${this.lhs(s.target)} = ${conv}${tr()}`, s.line);
return;
}
case 'Output': {
const vals = s.values.map((v: any) => this.outputValue(v));
this.emit(d, `print(${vals.join(', ')}${vals.length > 1 ? ', sep=""' : ''})${tr()}`, s.line);
return;
}
case 'If': {
const conds = s.branches.map((b: any, i: number) => { this.hoistOK = i === 0; try { return this.expr(b.cond); } finally { this.hoistOK = true; } });
s.branches.forEach((b: any, i: number) => {
this.emit(d, `${i ? 'elif' : 'if'} ${conds[i]}:${i ? this.trailing(b.line) : tr()}`, b.line);
this.block(b.body, d + 1, ctx);
});
if (s.elseBody) { this.emit(d, 'else:', s.elseLine); this.block(s.elseBody, d + 1, ctx); }
return;
}
case 'Case': {
const subj = this.expr(s.subject);
const arms = s.arms.map((a: any) => a.labels.map((l: any) => (l.value ? `${subj} == ${this.expr(l.value)}` : `${this.expr(l.low)} <= ${subj} < ${this.expr(l.high)}`)).join(' or '));
s.arms.forEach((a: any, i: number) => {
this.emit(d, `${i ? 'elif' : 'if'} ${arms[i]}:`, a.line);
this.block(a.body, d + 1, ctx);
});
if (s.otherwise) { this.emit(d, s.arms.length ? 'else:' : 'if True:', s.otherwiseLine); this.block(s.otherwise, d + 1, ctx); }
this.note('case', 'Mojo has no CASE statement: it becomes a chain of if and elif.');
return;
}
case 'For': {
const i = this.name(s.var);
const a = this.expr(s.start); const b = this.expr(s.stop);
const r = s.step ? `range(${a}, ${b}, ${this.expr(s.step)})` : a === '0' ? `range(${b})` : `range(${a}, ${b})`;
for (const inv of s.invariants || []) this.emit(d, `# INVARIANT ${sourceOf(inv.expr)}`, inv.line);
if (s.parallel) this.emit(d, '# PARALLEL FOR: the passes are independent; this translation runs them one after another', s.line);
this.emit(d, `for ${i} in ${r}:${tr()}`, s.line);
this.block(s.body, d + 1, ctx);
return;
}
case 'ForEach': {
const x = this.name(s.var);
const it = s.iterable;
const coll = this.expr(it);
if (it.type?.k === 'STRING') {
const k = this.fresh(`${x}_pos`);
this.emit(d, `for ${k} in range(${coll}.count_codepoints()):${tr()}`, s.line);
this.emit(d + 1, `var ${x} = String(${coll}[codepoint=${k}])`, s.line);
} else if (it.type?.k === 'HASHMAP' || it.type?.k === 'SET') {
this.emit(d, `for ${x} in ${coll}${it.type.k === 'HASHMAP' ? '.keys()' : ''}:${tr()}`, s.line);
this.note('each-order', 'The lab visits SET members and HASHMAP keys smallest first. Mojo visits them in its own order, which the notation never promised; a program whose answer depends on that order is worth rewriting.');
} else if (it.kind === 'Range') {
this.emit(d, `for ${x} in range(${this.expr(it.lo)}, ${this.expr(it.hi)}):${tr()}`, s.line);
} else {
// FOR EACH walks a snapshot, so a body that changes the list does not change the walk
const r = rootName(it);
const snap = r && this.changedIn(s.body).has(up(r));
if (snap) this.note('each-snapshot', 'FOR EACH walks the collection as it was when the loop began. The body changes it, so the translation walks a copy.');
this.emit(d, `for ${x} in ${snap ? `${coll}.copy()` : coll}:${tr()}`, s.line);
}
this.block(s.body, d + 1, ctx);
return;
}
case 'While': {
this.hoistOK = false;
let cond: string;
try { cond = this.expr(s.cond); } finally { this.hoistOK = true; }
for (const inv of s.invariants || []) this.emit(d, `# INVARIANT ${sourceOf(inv.expr)}`, inv.line);
if (s.decreases) this.emit(d, `# DECREASES ${sourceOf(s.decreases.expr)}`, s.decreases.line);
this.emit(d, `while ${cond}:${tr()}`, s.line);
this.block(s.body, d + 1, ctx);
return;
}
case 'Repeat': {
this.hoistOK = false;
let cond: string;
try { cond = this.expr(s.cond); } finally { this.hoistOK = true; }
this.emit(d, `while True:${tr()}`, s.line);
this.block(s.body, d + 1, ctx);
this.emit(d + 1, `if ${cond}:`, s.endLine);
this.emit(d + 2, 'break', s.endLine);
this.note('repeat', 'REPEAT ... UNTIL has no direct counterpart: it becomes while True, with a break at the end once the UNTIL condition holds.');
return;
}
case 'Break': this.emit(d, `break${tr()}`, s.line); return;
case 'Continue': this.emit(d, `continue${tr()}`, s.line); return;
case 'Return': {
if (!s.value) { this.emit(d, `return${tr()}`, s.line); return; }
const v = this.copied(s.value, this.withHint(ctx.sub?.returns, () => this.expr(s.value)));
this.emit(d, `return ${this.widened(ctx.sub?.returns, s.value, v)}${tr()}`, s.line);
return;
}
case 'Call': {
const flags = this.varParams.get(key(s.name)) || [];
const args = s.args.map((a: any, i: number) => this.callArg(a, s.sub?.params?.[i], flags[i]));
this.emit(d, `${this.name(s.name)}(${args.join(', ')})${tr()}`, s.line);
return;
}
case 'BuiltinCall': this.emit(d, `${this.builtinStmt(s)}${tr()}`, s.line); return;
case 'ExprStmt': this.emit(d, `${this.expr(s.expr)}${tr()}`, s.line); return;
case 'Assert': {
const c = this.expr(s.expr);
this.emit(d, `if not (${c}):`, s.line);
this.emit(d + 1, `raise Error("ASSERT failed on pseudo line ${s.line}: ${sourceOf(s.expr).replace(/["\\]/g, '')}")`, s.line);
return;
}
case 'BlankStmt': this.gap(`a blank to fill in: <${s.text}>`); return;
default: return;
}
}
/** DECLARE A : ARRAY[n] OF T: a list filled to its length, the way the verified programs do it (an append loop, since List(length=) is not run by the interpreter). */
arrayDecl(v: string, t: any, d: number, line: number): void {
const dims = (t.dimExprs || []).map((x: any) => this.expr(x));
const fill = this.defaultOf(t.of);
if (dims.length === 2) {
const row = this.fresh('row');
this.emit(d, `var ${v} = ${this.type(t)}()`, line);
this.emit(d, `for _ in range(${dims[0]}):`, line);
this.emit(d + 1, `var ${row} = List[${this.type(t.of)}]()`, line);
this.emit(d + 1, `for _ in range(${dims[1]}):`, line);
this.emit(d + 2, `${row}.append(${fill})`, line);
this.emit(d + 1, `${v}.append(${row}^)`, line);
} else {
this.emit(d, `var ${v} = ${this.type(t)}()`, line);
this.emit(d, `for _ in range(${dims[0]}):`, line);
this.emit(d + 1, `${v}.append(${fill})`, line);
}
this.note('array', 'A fixed-length ARRAY becomes a list filled to its full length with an append loop, so every cell holds a value.');
}
callArg(a: any, param: any, owned: boolean | undefined): string {
const text = this.widened(param?.type, a, this.withHint(param?.type, () => this.expr(a)));
return owned ? this.copied(a, text) : text;
}
builtinStmt(s: any): string {
const [a, b, c] = s.args.map((x: any) => this.expr(x));
switch (s.name) {
case 'APPEND': return `${a}.append(${b})`;
case 'INSERT': return `${a}.insert(${b}, ${c})`;
case 'REMOVE': return `_ = ${a}.pop(${b})`;
case 'ADD': return `${a}.add(${b})`;
case 'DELETE': return `_ = ${a}.pop(${b})`;
case 'SORT': this.need('sort'); return `sort(${a})`;
default: return this.gap(`the built-in ${s.name}`);
}
}
lhs(t: any): string { return this.expr(t, true); }
outputValue(v: any): string {
if (v.type?.k === 'BOOL') return `("TRUE" if ${this.expr(v)} else "FALSE")`;
return this.expr(v);
}
/* ---------- expressions ---------- */
/** An iteration source for a quantifier or set builder: a range, or a collection's items. */
domain(dom: any): string {
return dom.kind === 'Range' ? `range(${this.expr(dom.lo)}, ${this.expr(dom.hi)})` : this.expr(dom);
}
expr(e: any, isTarget = false): string {
const P = (x: any) => (x && ['Binary', 'Chain', 'Quant', 'Unary'].includes(x.kind) ? `(${this.expr(x)})` : this.expr(x));
switch (e.kind) {
case 'Num': { const t = String(e.value); return e.float && !/[.e]/.test(t) ? `${t}.0` : t; }
case 'Str': case 'Char': return JSON.stringify(e.value);
case 'Bool': return e.value ? 'True' : 'False';
case 'Blank': return this.gap(`a blank to fill in: <${e.text}>`);
case 'TypeRef': return e.name === 'INTEGER' ? 'Int' : e.name === 'FLOAT' || e.name === 'FLOAT64' ? 'Float64' : e.name === 'FLOAT32' ? 'Float32' : e.name.startsWith('UINT') ? `UInt${e.name.slice(4)}` : `Int${e.name.slice(3)}`;
case 'Name':
if (e.sym?.kind === 'const') return this.constName(e.name);
if (e.sym?.kind === 'define') return `${this.name(e.name)}()`;
if (up(e.name) === 'RESULT' && e.sym?.kind === 'result') return this.gap('RESULT');
return this.name(e.name);
case 'Unary': return e.op === 'NOT' ? `not ${P(e.arg)}` : `-${P(e.arg)}`;
case 'Binary': {
const map: Record<string, string> = { AND: 'and', OR: 'or', DIV: '//', MOD: '%', '^': '**', '&': '+', IN: 'in' };
if (e.op === '/') this.note('divide', 'In the notation, dividing by zero stops the program. In Mojo a Float64 division by zero gives inf or nan and the program goes on.');
if (e.op === '/' && mojoNumber(e.type) === 'Float32') {
const side = (x: any) => (x.kind === 'Num' || mojoNumber(x.type) === 'Float32' ? this.sideExpr(x, e, x === e.left ? 'l' : 'r') : `Float32(${this.expr(x)})`);
return `${side(e.left)} / ${side(e.right)}`;
}
if (e.op === '/') return `Float64(${this.expr(e.left)}) / Float64(${this.expr(e.right)})`;
if (isSized(e.type) && e.type.k === 'INTEGER' && ['+', '-', '*', '^', 'DIV', 'MOD'].includes(e.op)) this.note('sized', 'In the notation, a value that does not fit a sized whole-number type stops the run. In Mojo, Int8 and the other fixed-width types wrap around silently, and a conversion such as Int8(x) keeps only the low bits.');
if (e.op === 'IN' && e.right.kind === 'Range') return `${this.expr(e.right.lo)} <= ${P(e.left)} < ${this.expr(e.right.hi)}`;
if (e.op === '&') {
const side = (x: any) => (x.type?.k === 'CHAR' || x.type?.k === 'STRING' ? P(x) : `String(${this.expr(x)})`);
return `${side(e.left)} + ${side(e.right)}`;
}
let left = this.sideExpr(e.left, e, 'l');
// Mojo folds arithmetic on float literals exactly (0.1 + 0.2 == 0.3); the notation computes with Float64, so the left side is made one
if (litOnly(e.left) && litOnly(e.right) && (hasFloatLit(e.left) || hasFloatLit(e.right)) && !left.startsWith('Float64(') && ['+', '-', '*', '==', '!=', '<', '<=', '>', '>='].includes(e.op)) left = `Float64(${left})`;
return `${left} ${map[e.op] || e.op} ${this.sideExpr(e.right, e, 'r')}`;
}
case 'Chain': return e.operands.map((o: any, i: number) => (i ? `${e.ops[i - 1] === 'IN' ? 'in' : e.ops[i - 1]} ${P(o)}` : P(o))).join(' ');
case 'Index': {
const t = this.expr(e.target);
if (e.target.type?.k === 'STRING' && !isTarget) return `String(${t}[codepoint=${this.expr(e.indices[0])}])`;
if (e.indices.length === 2) return `${t}[${this.expr(e.indices[0])}][${this.expr(e.indices[1])}]`;
return `${t}[${this.expr(e.indices[0])}]`;
}
case 'Field': return `${this.expr(e.target)}.${this.name(e.field)}`;
case 'CallExpr': return this.call(e);
case 'ListLit': {
const t = e.type?.k === 'LIST' && e.type.of?.k !== 'ANY' ? e.type : this.hint?.k === 'LIST' || this.hint?.k === 'ARRAY' ? this.hint : e.type;
return `${this.type(t)}(${e.items.map((x: any) => this.withHint(t?.of, () => this.expr(x))).join(', ')})`;
}
case 'SetLit': this.need('Set'); return `${this.type(e.type?.of?.k !== 'ANY' ? e.type : this.hint)}(${e.items.map((x: any) => this.expr(x)).join(', ')})`;
case 'MapLit': return `{${e.entries.map((x: any) => `${this.expr(x.key)}: ${this.expr(x.value)}`).join(', ')}}`;
case 'Range': return `range(${this.expr(e.lo)}, ${this.expr(e.hi)})`;
case 'SetBuilder': {
const v = this.name(e.var);
const dom = this.domain(e.domain);
const t = this.fresh('set');
this.hoistOK = false;
let body: string;
try { body = this.expr(e.body); } finally { this.hoistOK = true; }
this.hoist([[0, `var ${t} = ${this.type(e.type)}()`], [0, `for ${v} in ${dom}:`], [1, `if ${body}:`], [2, `${t}.add(${v})`]]);
this.note('comprehension', 'Mojo has no set comprehension, so a set written by rule becomes a loop, written just before the line that uses it, that fills a Set.');
return t;
}
case 'Quant': {
const v = this.name(e.var);
const dom = this.domain(e.domain);
const t = this.fresh(e.q === 'FORALL' ? 'all' : e.q === 'EXISTS' ? 'any' : 'sum');
const saved = this.hoistOK;
this.hoistOK = false;
let body: string;
try { body = this.expr(e.body); } finally { this.hoistOK = saved; }
if (e.q === 'FORALL') this.hoist([[0, `var ${t} = True`], [0, `for ${v} in ${dom}:`], [1, `if not (${body}):`], [2, `${t} = False`], [2, 'break']]);
else if (e.q === 'EXISTS') this.hoist([[0, `var ${t} = False`], [0, `for ${v} in ${dom}:`], [1, `if ${body}:`], [2, `${t} = True`], [2, 'break']]);
else this.hoist([[0, `var ${t} = ${e.type?.k === 'FLOAT' ? '0.0' : '0'}`], [0, `for ${v} in ${dom}:`], [1, `${t} += ${body}`]]);
this.note('quantifier', 'FORALL, EXISTS, and SUM have no one-line Mojo spelling; they become a loop, written just before the line that uses them, that sets a flag or adds to a running total.');
return t;
}
default: return this.gap(`a ${e.kind} expression`);
}
}
/** An operand of a binary operator: parenthesized when precedence needs it, and an Int meeting a Float64 is converted. */
sideExpr(x: any, parent: any, side: 'l' | 'r'): string {
const BIND: Record<string, number> = { OR: 1, AND: 2, '==': 4, '!=': 4, '<': 4, '<=': 4, '>': 4, '>=': 4, IN: 4, '&': 5, '+': 6, '-': 6, '*': 7, '/': 7, DIV: 7, MOD: 7, '^': 9 };
let s = this.expr(x);
const other = side === 'l' ? parent.right : parent.left;
if (['+', '-', '*', '==', '!=', '<', '<=', '>', '>=', 'DIV', 'MOD', '^'].includes(parent.op) && x.kind !== 'Num' && other?.type) {
// two sides of different number types meet as the notation has them meet
const mine = mojoNumber(x.type); const theirs = mojoNumber(other.type);
const compare = ['==', '!=', '<', '<=', '>', '>='].includes(parent.op);
if (mine && theirs && mine !== theirs) {
if (x.type.k === 'INTEGER' && other.type.k === 'FLOAT') s = `${theirs}(${s})`;
else if (x.type.k === 'INTEGER' && other.type.k === 'INTEGER' && !x.type.bits) s = `${theirs}(${s})`;
else if (compare && x.type.k === 'FLOAT' && other.type.k === 'FLOAT' && mine === 'Float32') s = `Float64(${s})`;
else if (compare && x.type.k === 'INTEGER' && other.type.k === 'INTEGER') s = `Int(${s})`;
}
}
if (x.kind === 'Chain' || x.kind === 'Quant') return `(${s})`;
if (x.kind === 'Unary' && x.op === 'NOT' && BIND[parent.op] > 3) return `(${s})`;
if (x.kind !== 'Binary') return s;
const a = BIND[x.op]; const b = BIND[parent.op];
if (a < b || (a === b && side === 'r' && !(parent.op === x.op && ['+', '*', 'AND', 'OR', '&'].includes(parent.op))) || (a === 4 && b === 4)) return `(${s})`;
return s;
}
/** A value as the Mojo number type T: unchanged when it already is one, or a literal; converted otherwise. */
as(T: string, node: any, text: string): string {
if (mojoNumber(node?.type) === T) return text;
return `${T}(${text})`;
}
/** IS_CLOSE's four values, as Float64 unless they are already FLOATs of one precision. */
args4(e: any): string[] {
const f32 = e.args.slice(0, 2).every((x: any) => mojoNumber(x.type) === 'Float32');
return e.args.map((x: any) => (x.kind === 'Num' || mojoNumber(x.type) === (f32 ? 'Float32' : 'Float64') ? this.expr(x) : `${f32 ? 'Float32' : 'Float64'}(${this.expr(x)})`));
}
/** A built-in that is a short loop: write it before the statement and name its result. */
loopResult(stem: string, type: string, init: string, lines: Array<[number, string]>): string {
const t = this.fresh(stem);
this.hoist([[0, `var ${t}${type ? `: ${type}` : ''} = ${init}`], ...lines.map(([d, x]): [number, string] => [d, x.split('$T').join(t)])]);
return t;
}
call(e: any): string {
if (e.isOld) return this.gap('OLD(...) outside a contract');
if (e.convert) {
const to = mojoNumber(e.type)!;
if (e.type.k === 'INTEGER') this.note('sized', 'In the notation, a value that does not fit a sized whole-number type stops the run. In Mojo, Int8 and the other fixed-width types wrap around silently, and a conversion such as Int8(x) keeps only the low bits.');
const arg = e.args[0];
// a FLOAT literal becomes a Float64 first, so the conversion is from a runtime value, as in the notation
return `${to}(${arg.kind === 'Num' && arg.float ? `Float64(${this.expr(arg)})` : this.expr(arg)})`;
}
if (!e.builtin) {
const flags = this.varParams.get(key(e.name)) || [];
const args = e.args.map((a: any, i: number) => this.callArg(a, e.sub?.params?.[i], flags[i]));
return `${this.name(e.name)}(${args.join(', ')})`;
}
const args: string[] = e.args.map((a: any) => this.expr(a));
const [a, b, c] = args;
const t0 = e.args[0]?.type?.k;
const math = (f: string): string => { this.need(f); return `${f}(Float64(${a}))`; };
switch (e.builtin) {
case 'LENGTH': return t0 === 'STRING' ? `${a}.count_codepoints()` : `len(${a})`;
case 'ROWS': return `len(${a})`;
case 'COLUMNS': return `len(${a}[0])`;
case 'INT': return `Int(${a})`;
case 'ROUND': return `Int(round(${a}))`;
case 'ABS': return `abs(${a})`;
case 'MIN': case 'MAX': {
const mixed = e.type?.k === 'FLOAT' && e.args.length > 1 && e.args.some((x: any) => x.type?.k === 'INTEGER');
return `${e.builtin.toLowerCase()}(${args.map((x, i) => (mixed ? this.widened(e.type, e.args[i], x) : x)).join(', ')})`;
}
case 'SQRT': return math('sqrt');
case 'EXP': return math('exp');
case 'LOG': return math('log');
case 'LOG2': return math('log2');
case 'LOG10': return math('log10');
case 'SIN': return math('sin');
case 'COS': return math('cos');
case 'TAN': return math('tan');
case 'ATAN2': this.need('atan2'); return `atan2(Float64(${a}), Float64(${b}))`;
case 'PI': this.need('pi'); return 'pi';
case 'CHOOSE': this.need('comb'); return `comb(${a}, ${b})`;
case 'FLOOR': this.need('floor'); return `Int(floor(${a}))`;
case 'CEIL': this.need('ceil'); return `Int(ceil(${a}))`;
case 'RAND': this.need('random_float64'); return `random_float64() * ${a}`;
case 'RANDINT': this.need('random_si64'); return `Int(random_si64(${a}, ${b} - 1))`;
case 'SLICE':
if (t0 === 'STRING') {
// the verified programs build a piece of a String letter by letter; s[byte=a:b] counts bytes and is not run by the interpreter
const k = this.fresh('at');
this.note('slice', 'A piece of a String is built letter by letter, which counts characters the way the notation does.');
return this.loopResult('piece', '', 'String("")', [[0, `for ${k} in range(${b}, ${c}):`], [1, `$T += String(${a}[codepoint=${k}])`]]);
}
return `${a}[${b}:${c}]`;
case 'UPPER': return `${a}.upper()`;
case 'LOWER': return `${a}.lower()`;
case 'ORD': return `ord(${a})`;
case 'CHR': return `chr(${a})`;
case 'TO_STRING': return `String(${a})`;
case 'TO_INTEGER': return `atol(${a})`;
case 'TO_FLOAT': return t0 === 'STRING' ? `atof(${a})` : `Float64(${a})`;
case 'REPLACE': return `${a}.replace(${b}, ${c})`;
case 'JOIN': return `${b}.join(${a})`;
case 'INDEX_OF':
if (t0 === 'STRING') return `${a}.find(${b})`;
{
const i = this.fresh('i');
return this.loopResult('at', '', '-1', [[0, `for ${i} in range(len(${a})):`], [1, `if ${a}[${i}] == ${b}:`], [2, `$T = ${i}`], [2, 'break']]);
}
case 'SPLIT': {
const p = this.fresh('piece');
const parts = this.fresh('parts');
this.hoist([[0, `var ${parts} = List[String]()`], [0, `for ${p} in ${a}.split(${b}):`], [1, `${parts}.append(String(${p}))`]]);
return parts;
}
case 'FILL': {
const ty = this.type(e.type?.of ?? e.args[1]?.type);
return this.loopResult('fill', '', `List[${ty}]()`, [[0, 'for _ in range(' + a + '):'], [1, `$T.append(${b})`]]);
}
case 'SUM_OF': {
const x = this.fresh('x');
if (isSized(e.type)) return this.loopResult('total', this.type(e.type), '0', [[0, `for ${x} in ${a}:`], [1, `$T += ${x}`]]);
const zero = e.type?.k === 'FLOAT' ? '0.0' : '0';
return this.loopResult('total', '', zero, [[0, `for ${x} in ${a}:`], [1, `$T += ${x}`]]);
}
case 'MEAN_OF': {
const x = this.fresh('x');
const sum = this.loopResult('total', '', '0.0', [[0, `for ${x} in ${a}:`], [1, `$T += Float64(${x})`]]);
return `(${sum} / Float64(len(${a})))`;
}
case 'DOT': {
const i = this.fresh('i');
if (isSized(e.type)) return this.loopResult('dot', this.type(e.type), '0', [[0, `for ${i} in range(len(${a})):`], [1, `$T += ${a}[${i}] * ${b}[${i}]`]]);
return this.loopResult('dot', '', e.type?.k === 'FLOAT' ? '0.0' : '0', [[0, `for ${i} in range(len(${a})):`], [1, `$T += ${a}[${i}] * ${b}[${i}]`]]);
}
case 'VARIANCE_OF': case 'STDEV_OF': {
const x = this.fresh('x');
const m = this.loopResult('mean', '', '0.0', [[0, `for ${x} in ${a}:`], [1, `$T += Float64(${x})`]]);
this.hoist([[0, `${m} = ${m} / Float64(len(${a}))`]]);
const v = this.loopResult('var', '', '0.0', [[0, `for ${x} in ${a}:`], [1, `$T += (Float64(${x}) - ${m}) * (Float64(${x}) - ${m})`]]);
this.hoist([[0, `${v} = ${v} / Float64(len(${a}) - 1)`]]);
this.note('statistics', 'The standard library has no variance or standard deviation, so they are written as loops: the sample variance divides by n - 1, as the notation does.');
if (e.builtin === 'VARIANCE_OF') return v;
this.need('sqrt');
return `sqrt(${v})`;
}
case 'NORM_OF': {
const x = this.fresh('x');
this.need('sqrt');
const q = this.loopResult('squares', '', '0.0', [[0, `for ${x} in ${a}:`], [1, `$T += Float64(${x}) * Float64(${x})`]]);
return `sqrt(${q})`;
}
case 'MEDIAN_OF': {
const x = this.fresh('x');
this.need('sort');
const of = e.args[0].type?.of;
const sorted = this.loopResult('sorted', '', `${this.type({ k: 'LIST', of })}()`, [[0, `for ${x} in ${a}:`], [1, `$T.append(${x})`]]);
this.hoist([[0, `sort(${sorted})`]]);
const mid = this.loopResult('median', '', '0.0', [
[0, `if len(${sorted}) % 2 == 1:`], [1, `$T = Float64(${sorted}[len(${sorted}) // 2])`],
[0, 'else:'], [1, `$T = (Float64(${sorted}[len(${sorted}) // 2 - 1]) + Float64(${sorted}[len(${sorted}) // 2])) / 2.0`],
]);
return mid;
}
case 'KEYS': {
const k = this.fresh('k');
this.need('sort');
const keys = this.loopResult('keys', '', `${this.type({ k: 'LIST', of: e.args[0].type.key })}()`, [[0, `for ${k} in ${a}.keys():`], [1, `$T.append(${k})`]]);
this.hoist([[0, `sort(${keys})`]]);
return keys;
}
case 'SORTED': {
const k = this.fresh('x');
this.need('sort');
const of = e.args[0].type?.k === 'SET' ? e.args[0].type.of : e.args[0].type?.of;
const items = this.loopResult('sorted', '', `${this.type({ k: 'LIST', of })}()`, [[0, `for ${k} in ${a}:`], [1, `$T.append(${k})`]]);
this.hoist([[0, `sort(${items})`]]);
return items;
}
// ---- numerical work
case 'ASIN': return math('asin');
case 'ACOS': return math('acos');
case 'ATAN': return math('atan');
case 'SINH': return math('sinh');
case 'COSH': return math('cosh');
case 'TANH': return math('tanh');
case 'CBRT': return math('cbrt');
case 'EXPM1': return math('expm1');
case 'LOG1P': return math('log1p');
case 'HYPOT': this.need('hypot'); return `hypot(Float64(${a}), Float64(${b}))`;
case 'POW': return `Float64(${a}) ** Float64(${b})`;
case 'COPYSIGN': this.need('copysign'); return `copysign(Float64(${a}), Float64(${b}))`;
case 'E': return '2.718281828459045';
case 'TRUNC': this.need('trunc'); return `trunc(${e.args[0].type?.k === 'FLOAT' ? a : `Float64(${a})`})`;
case 'SIGN': { const T = this.type(e.type); return `(${T}(1) if ${a} > 0 else (${T}(-1) if ${a} < 0 else ${T}(0)))`; }
case 'CLAMP': return `min(max(${a}, ${b}), ${c})`;
case 'FMA': { const T = mojoNumber(e.type)!; this.need('fma'); return `fma(${this.as(T, e.args[0], a)}, ${this.as(T, e.args[1], b)}, ${this.as(T, e.args[2], c)})`; }
case 'IS_NAN': this.need('isnan'); return `isnan(${e.args[0].type?.k === 'FLOAT' ? a : `Float64(${a})`})`;
case 'IS_INF': this.need('isinf'); return `isinf(${e.args[0].type?.k === 'FLOAT' ? a : `Float64(${a})`})`;
case 'IS_FINITE': this.need('isfinite'); return `isfinite(${e.args[0].type?.k === 'FLOAT' ? a : `Float64(${a})`})`;
case 'INF': this.need('inf'); return 'inf[DType.float64]()';
case 'NAN': this.need('nan'); return 'nan[DType.float64]()';
case 'ULP': { const T = mojoNumber(e.type)!; this.need('ulp'); return `ulp(${this.as(T, e.args[0], a)})`; }
case 'NEXT_AFTER': { const T = mojoNumber(e.type)!; this.need('nextafter'); return `nextafter(${this.as(T, e.args[0], a)}, ${this.as(T, e.args[1], b)})`; }
case 'IS_CLOSE': {
const d = this.args4(e);
return `(${d[0]} == ${d[1]} or abs(${d[0]} - ${d[1]}) <= max(${d[2]} * max(abs(${d[0]}), abs(${d[1]})), ${d[3]}))`;
}
case 'MAX_VALUE': case 'MIN_VALUE': case 'EPSILON': {
const T = mojoNumber(e.type)!;
const ty = e.type;
if (e.builtin === 'EPSILON') return `${T}(${ty.bits === 32 ? '1.1920928955078125e-07' : '2.220446049250313e-16'})`;
if (ty.k === 'INTEGER') {
const hi = ty.signed ? 2 ** (ty.bits - 1) - 1 : 2 ** ty.bits - 1; const lo = ty.signed ? -(2 ** (ty.bits - 1)) : 0;
return `${T}(${e.builtin === 'MAX_VALUE' ? hi : lo})`;
}
const m = ty.bits === 32 ? '3.4028234663852886e38' : '1.7976931348623157e308';
return `${T}(${e.builtin === 'MAX_VALUE' ? m : `-${m}`})`;
}
case 'GCD': this.need('gcd'); return `gcd(${a}, ${b})`;
case 'LCM': this.need('lcm'); return `lcm(${a}, ${b})`;
case 'BIT_AND': return `(${a} & ${b})`;
case 'BIT_OR': return `(${a} | ${b})`;
case 'BIT_XOR': return `(${a} ^ ${b})`;
case 'BIT_NOT': return `~${a}`;
case 'SHIFT_LEFT': case 'SHIFT_RIGHT': {
const T = this.type(e.type);
const n = isSized(e.type) ? `${T}(${b})` : b;
if (e.builtin === 'SHIFT_LEFT' && isSized(e.type)) this.note('sized', 'In the notation, a value that does not fit a sized whole-number type stops the run. In Mojo, Int8 and the other fixed-width types wrap around silently, and a conversion such as Int8(x) keeps only the low bits.');
return `(${a} ${e.builtin === 'SHIFT_LEFT' ? '<<' : '>>'} ${n})`;
}
case 'WRAP': return `${this.type(e.type)}(${a})`;
default:
return this.gap(`the built-in ${e.builtin}, which Mojo's standard library has no function for`);
}
}
}
/* ------------------------------------------------------------------ */
/* Entry point */
/* ------------------------------------------------------------------ */
/**
* Translate pseudo to Mojo. Returns `unsupported` only when the pseudo does
* not parse or check; everything else yields Mojo, with a diagnostic for each
* line that could not be translated.
*/
export function pseudoToMojo(pseudo: string, opts: MojoOptions = {}): MojoResult | { unsupported: Diagnostic[] } {
const st: any = study(pseudo, { coach: false });
if (!st.ok || !st.program) {
const errors = (st.diags as any[]).filter((d) => d.severity === 'error').map((d) => toDiagnostic(d));
return { unsupported: errors.length ? errors : [{ lang: 'pseudo', severity: 'error', id: 'translate-no-program', line: 1, message: 'The pseudo does not read yet, so there is nothing to translate.' }] };
}
const program = st.program;
// the library routines the program uses, each once, the ones they use first
const libs = libraryOrder(program);
const libRaising = new Set<string>();
const libraryBlocks: Array<{ id: string; lines: string[]; imports: string[] }> = [];
for (const lib of libs) {
const raising = inferRaising(lib.program, libRaising);
const gen = new Gen(lib.program, lib.source, raising, { defsOnly: true });
gen.run();
for (const sub of lib.program.subs.values()) if (raising.has(up(sub.name))) libRaising.add(up(sub.name));
const lines = gen.out.map((l) => l.text);
while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
libraryBlocks.push({ id: lib.id, lines, imports: [...gen.imports] });
}
opts = { ...opts, libraryBlocks };
const callText = (opts.call || '').trim();
const callName = callText ? /^\s*([A-Za-z_][A-Za-z0-9_]*)/.exec(callText)?.[1] : null;
// Inference, then translation; a line that could not be translated becomes a raise, so its routine raises too, and the pass is run again.
const extra = new Set<string>(libRaising);
for (let pass = 0; ; pass++) {
const raising = inferRaising(program, extra);
if (bodyRaises(program.main.body, raising)) raising.add('MAIN');
if (callName && raising.has(up(callName))) raising.add('MAIN');
for (const k of extra) if (k === 'MAIN') raising.add('MAIN');
const gen = new Gen(program, pseudo, raising, opts);
const result = gen.run();
const fresh = [...gen.gapOwners].map(up).filter((k) => !raising.has(k === 'MAIN' ? 'MAIN' : k));
if (!fresh.length || pass >= 3) return result;
for (const k of fresh) extra.add(k);
}
}
/** The names of every routine a program calls, anywhere in it. */
function calledNames(program: any): Set<string> {
const out = new Set<string>();
const seen = new Set<any>();
const visit = (x: any): void => {
if (!x || typeof x !== 'object' || seen.has(x)) return;
seen.add(x);
if (Array.isArray(x)) { for (const y of x) visit(y); return; }
if ((x.kind === 'CallExpr' || x.kind === 'Call') && x.name) out.add(up(x.name));
for (const [k, v] of Object.entries(x)) if (k !== 'sub' && k !== 'sym' && k !== 'type' && k !== 'resolved' && v && typeof v === 'object') visit(v);
};
visit(program.main?.body);
for (const s of program.subs.values()) { visit(s.node.body); visit(s.requires); visit(s.ensures); }
return out;
}
/** Every library routine a program calls, directly or through another routine, dependencies first, each once. */
function libraryOrder(program: any, out: Map<string, any> = new Map()): any[] {
const called = calledNames(program);
for (const sub of program.libs?.values() ?? []) {
if (!called.has(up(sub.name))) continue;
if (out.has(sub.lib.id)) continue;
libraryOrder(sub.lib.program, out);
out.set(sub.lib.id, sub.lib);
}
return [...out.values()];
}
/** The set of names a generated source may use from the standard library, for the grounding test. */
export function stdlibNamesUsed(): string[] { return Object.keys(USED_STDLIB); }
export const STD_INDEX = MOJO_STD_EXPORTS;