tricu

compiler.js (3811B)

---

 import { bundleHash } from './bundle.js';
 import { text, readText, readList, readNatural } from './codecs.js';
 export const COMPILER_EXPORT = 'source_unit.compileStableModuleDefinitions';
 export function compilerDescriptor(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         throw new Error('Invalid compiler descriptor');
     const descriptor = raw;
     if (descriptor['schema'] !== 1 || descriptor['backend'] !== 'stable' || descriptor['export'] !== COMPILER_EXPORT)
         throw new Error('Invalid stable compiler descriptor');
     return { hash: bundleHash(descriptor['hash']) };
 }
 export const COMPILER_COLLECTION = Object.freeze({ threshold: 250_000 });
 export const SOURCE_LIMIT = 16_384;
 export function sourceText(source) {
     if (typeof source !== 'string' || !source.trim())
         throw new Error('Enter a source unit or native module');
     if (source.length > SOURCE_LIMIT * 2)
         throw new Error('Source limit exceeded');
     let count = 0;
     for (const char of source) {
         if (++count > SOURCE_LIMIT)
             throw new Error('Source limit exceeded');
         const scalar = char.codePointAt(0);
         if (scalar >= 0xd800 && scalar <= 0xdfff)
             throw new Error('Unpaired source surrogate');
     }
     return source;
 }
 export function sourceLiteral(graph, source) {
     return text(graph, sourceText(source), SOURCE_LIMIT);
 }
 export function compilerDiagnostic(graph, payload) {
     const [diagnostic] = graph.pair(payload, 'compiler error payload');
     const [code, tail] = graph.pair(diagnostic, 'diagnostic code');
     const [expected, fields] = graph.pair(tail, 'diagnostic expected');
     const [, locationFields] = graph.pair(fields, 'diagnostic found');
     const [location] = graph.pair(locationFields, 'diagnostic location');
     let where = '';
     if (graph.observe(location).node.kind !== 'leaf') {
         const [line, rest] = graph.pair(location, 'source position'), [column] = graph.pair(rest, 'source column');
         where = ` at ${readNatural(graph, line)}:${readNatural(graph, column)}`;
     }
     // Expected can be a token-kind number or a label; found/context/remainder
     // may be arbitrary trees. Decode only the compiler's known diagnostic profile.
     const number = readNatural(graph, code);
     const label = number === 2n ? `: expected token kind ${readNatural(graph, expected)}`
         : number === 20n ? `: unresolved name ${JSON.stringify(readText(graph, expected, 512))}`
             : number >= 30n ? `: expected ${JSON.stringify(readText(graph, expected, 512))}` : '';
     return `Compiler diagnostic ${number}${where}${label}`;
 }
 // Decode only the result spine/names. Compiled program trees remain lazy handles.
 // Do not normalize/serialize them merely to populate an export selector.
 export function compiledDefinitions(graph, result, allowEmpty = false) {
     const [tag, payload] = graph.pair(result, 'compiler result');
     const flag = graph.observe(tag).node;
     if (flag.kind === 'leaf')
         throw new Error(compilerDiagnostic(graph, payload));
     if (flag.kind !== 'stem' || graph.observe(flag.child).node.kind !== 'leaf')
         throw new Error('Invalid compiler result tag');
     const [definitions] = graph.pair(payload, 'compiler definitions payload');
     const bindings = readList(graph, definitions, 16), exports = new Map();
     for (const binding of bindings) {
         const [nameTree, program] = graph.pair(binding, 'compiled binding');
         const name = readText(graph, nameTree, 128);
         if (!name || exports.has(name))
             throw new Error('Empty/duplicate compiled definition name');
         exports.set(name, program);
     }
     if (!exports.size && !allowEmpty)
         throw new Error('Source unit produced no definitions');
     return exports;
 }