419 lines
14 KiB
TypeScript
419 lines
14 KiB
TypeScript
import type { AST, Pattern, Definition } from './ast';
|
|
import { store } from './runtime-js';
|
|
|
|
let matchCounter = 0;
|
|
|
|
type CompileCtx = {
|
|
useStore: boolean;
|
|
bound: Set<string>;
|
|
topLevel: Set<string>;
|
|
};
|
|
const defaultCtx: CompileCtx = { useStore: true, bound: new Set(), topLevel: new Set() };
|
|
|
|
export const definitions: Map<string, Definition> = new Map();
|
|
export const dependencies: Map<string, Set<string>> = new Map();
|
|
export const dependents: Map<string, Set<string>> = new Map();
|
|
export const astRegistry = new Map<number, AST>();
|
|
let astIdCounter = 0;
|
|
|
|
export function compile(ast: AST, ctx: CompileCtx = defaultCtx): string {
|
|
switch (ast.kind) {
|
|
case 'literal':
|
|
if (ast.value.kind === 'string')
|
|
return JSON.stringify(ast.value.value);
|
|
if (ast.value.kind === 'int' || ast.value.kind === 'float')
|
|
return JSON.stringify(ast.value.value);
|
|
throw new Error(`Cannot compile literal`); // of kind ${ast.value.kind}`);
|
|
|
|
case 'variable': {
|
|
if (ctx.bound.has(ast.name)) {
|
|
return sanitizeName(ast.name);
|
|
}
|
|
return sanitize(ast.name, ctx);
|
|
}
|
|
|
|
case 'lambda': {
|
|
const newBound = new Set([...ctx.bound, ...ast.params]);
|
|
const newCtx = { ...ctx, bound: newBound };
|
|
const params = ast.params.map(sanitizeName).join(') => (');
|
|
const id = astIdCounter++;
|
|
astRegistry.set(id, ast);
|
|
return `Object.assign((${params}) => ${compile(ast.body, newCtx)}, { _astId: (${id}) })`;
|
|
}
|
|
|
|
case 'apply':
|
|
// Constructor
|
|
if (ast.func.kind === 'constructor') {
|
|
const ctorName = ast.func.name;
|
|
const arg = compile(ast.args[0], ctx);
|
|
return `({ _tag: "${ctorName}", _0: ${arg} })`;
|
|
}
|
|
|
|
const args = ast.args.map(a => compile(a, ctx)).join(')(');
|
|
return `${compile(ast.func, ctx)}(${args})`;
|
|
|
|
case 'record': {
|
|
const parts = ast.entries.map(entry =>
|
|
entry.kind === 'spread'
|
|
? `...${compile(entry.expr, ctx)}`
|
|
: `${JSON.stringify(entry.key)}: ${compile(entry.value, ctx)}`
|
|
)
|
|
return `({${parts.join(', ')}})`;
|
|
}
|
|
|
|
case 'list': {
|
|
const elements = ast.elements.map(e =>
|
|
'spread' in e ? `...${compile(e.spread, ctx)}` : compile(e, ctx)
|
|
);
|
|
return `[${elements.join(', ')}]`;
|
|
}
|
|
|
|
case 'record-access':
|
|
return `${compile(ast.record, ctx)}[${JSON.stringify(ast.field)}]`;
|
|
|
|
case 'record-update':
|
|
const updates = Object.entries(ast.updates)
|
|
.map(([k, v]) => `${JSON.stringify(k)}: ${compile(v, ctx)}`);
|
|
return `({...${compile(ast.record, ctx)}, ${updates.join(', ')}})`;
|
|
|
|
case 'let': {
|
|
const newBound = new Set([...ctx.bound, ast.name]);
|
|
const newCtx = { ...ctx, bound: newBound };
|
|
return `(() => { let ${sanitizeName(ast.name)} = ${compile(ast.value, newCtx)};
|
|
return ${compile(ast.body, newCtx)}; })()`;
|
|
}
|
|
|
|
case 'match':
|
|
return compileMatch(ast, ctx);
|
|
|
|
case 'constructor':
|
|
return `({ _tag: "${ast.name}" })`;
|
|
|
|
case 'rebind': {
|
|
const rootName = getRootName(ast.target);
|
|
const path = getPath(ast.target);
|
|
const value = compile(ast.value, ctx);
|
|
|
|
if (!rootName) throw new Error('Rebind target must be a variable');
|
|
|
|
if (ctx.bound.has(rootName)) {
|
|
const target = compile(ast.target, ctx);
|
|
return `(() => { ${target} = ${value}; return { _tag: "NoOp" }; })()`;
|
|
}
|
|
|
|
if (path.length === 0) {
|
|
return `({ _tag: "Rebind", _0: "${rootName}", _1: ${value} })`;
|
|
} else {
|
|
return `({ _tag: "Rebind", _0: "${rootName}", _1: ${JSON.stringify(path)}, _2: ${value} })`;
|
|
}
|
|
}
|
|
|
|
default:
|
|
throw new Error(`Cannot compile ${ast.kind}`);
|
|
|
|
}
|
|
}
|
|
|
|
function sanitize(name: string, { useStore, topLevel }: CompileCtx): string {
|
|
if (!useStore && topLevel.has(name)) return sanitizeName(name);
|
|
return `store[${JSON.stringify(name)}]`
|
|
}
|
|
|
|
function sanitizeName(name: string): string {
|
|
const reserved = [
|
|
'default','class','function','return','const','let','var',
|
|
'if','else','switch','case','for','while','do','break',
|
|
'continue','new','delete','typeof','in','this','super',
|
|
'import','export','extends','static','yield','await','async',
|
|
'try','catch','finally','throw','null','true','false',
|
|
'eval','Function','window','document','console'
|
|
];
|
|
if (reserved.includes(name)) return `_${name}`;
|
|
|
|
return name.replace(/-/g, '_');
|
|
}
|
|
|
|
function compileMatch(ast: AST & { kind: 'match'}, ctx: CompileCtx): string {
|
|
const expr = compile(ast.expr, ctx);
|
|
const tmpVar = `_m${matchCounter++}`;
|
|
|
|
let code = `((${tmpVar}) => { `;
|
|
|
|
for (const c of ast.cases) {
|
|
const { condition, bindings } = compilePattern(c.pattern, tmpVar);
|
|
const patternBound = patternVars(c.pattern);
|
|
const newBound = new Set([...ctx.bound, ...patternBound]);
|
|
const newCtx = { ...ctx, bound: newBound };
|
|
code += `if (${condition}) { `;
|
|
if (bindings.length > 0) {
|
|
code += `const ${bindings.join(', ')}; `;
|
|
}
|
|
code += `return ${compile(c.result, newCtx)}; }`;
|
|
}
|
|
|
|
code += `console.error("No match for:", ${tmpVar}); throw new Error("No match"); })(${expr})`;
|
|
return code;
|
|
}
|
|
|
|
function compilePattern(pattern: Pattern, expr: string): { condition: string, bindings: string[] } {
|
|
switch (pattern.kind) {
|
|
case 'wildcard':
|
|
return { condition: 'true', bindings: [] };
|
|
|
|
case 'var':
|
|
return { condition: 'true', bindings: [`${sanitizeName(pattern.name)} = ${expr}`] };
|
|
|
|
case 'literal':
|
|
return { condition: `${expr} === ${JSON.stringify(pattern.value)}`, bindings: [] };
|
|
|
|
case 'constructor': {
|
|
let condition = `${expr}?._tag === "${pattern.name}"`;
|
|
const bindings: string[] = [];
|
|
pattern.args.forEach((argPattern, i) => {
|
|
const sub = compilePattern(argPattern, `${expr}._${i}`);
|
|
condition += ` && ${sub.condition}`;
|
|
bindings.push(...sub.bindings);
|
|
});
|
|
|
|
return { condition, bindings };
|
|
}
|
|
|
|
case 'list': {
|
|
let condition = `Array.isArray(${expr}) && ${expr}.length === ${pattern.elements.length}`;
|
|
const bindings: string[] = [];
|
|
pattern.elements.forEach((elemPattern, i) => {
|
|
const sub = compilePattern(elemPattern, `${expr}[${i}]`);
|
|
if (sub.condition !== 'true') condition += ` && ${sub.condition}`;
|
|
bindings.push(...sub.bindings);
|
|
});
|
|
|
|
return { condition, bindings };
|
|
}
|
|
|
|
case 'list-spread': {
|
|
let condition = `Array.isArray(${expr}) && ${expr}.length >= ${pattern.head.length}`;
|
|
const bindings: string[] = [];
|
|
pattern.head.forEach((elemPattern, i) => {
|
|
const sub = compilePattern(elemPattern, `${expr}[${i}]`);
|
|
if (sub.condition !== 'true') condition += ` && ${sub.condition}`;
|
|
bindings.push(...sub.bindings);
|
|
});
|
|
bindings.push(`${sanitizeName(pattern.spread)} = ${expr}.slice(${pattern.head.length})`);
|
|
|
|
return { condition, bindings };
|
|
}
|
|
|
|
case 'record': {
|
|
let condition = 'true';
|
|
const bindings: string[] = [];
|
|
for (const [field, fieldPattern] of Object.entries(pattern.fields)) {
|
|
const sub = compilePattern(fieldPattern, `${expr}[${JSON.stringify(field)}]`);
|
|
if (sub.condition !== 'true') condition += ` && ${sub.condition}`;
|
|
bindings.push(...sub.bindings);
|
|
}
|
|
|
|
return { condition, bindings };
|
|
}
|
|
|
|
default:
|
|
return { condition: 'true', bindings: [] };
|
|
}
|
|
}
|
|
|
|
export function compileAndRun(defs: Definition[]) {
|
|
const compiledDefs: string[] = [];
|
|
|
|
const topLevel = new Set(defs.map(d => d.name));
|
|
|
|
for (const def of defs) {
|
|
definitions.set(def.name, def);
|
|
const free = freeVars(def.body);
|
|
const deps = new Set([...free].filter(v => topLevel.has(v)));
|
|
dependencies.set(def.name, deps);
|
|
}
|
|
|
|
dependents.clear();
|
|
for (const name of topLevel) {
|
|
dependents.set(name, new Set());
|
|
}
|
|
|
|
for (const [name, deps] of dependencies) {
|
|
for (const dep of deps) {
|
|
dependents.get(dep)?.add(name);
|
|
}
|
|
}
|
|
|
|
for (const def of defs) {
|
|
const ctx: CompileCtx = { useStore: false, topLevel, bound: new Set() };
|
|
const compiled = `const ${sanitizeName(def.name)} = ${compile(def.body, ctx)};`;
|
|
compiledDefs.push(compiled);
|
|
|
|
try {
|
|
new Function('store', compiled);
|
|
} catch (e) {
|
|
console.error(`=== BROKEN: ${def.name} ===`);
|
|
console.error(compiled);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
const lastName = defs[defs.length - 1].name;
|
|
const defNames = defs.map(d => sanitizeName(d.name)).join(', ');
|
|
|
|
const code = `${compiledDefs.join('\n')}
|
|
return { ${defNames}, __result: ${sanitizeName(lastName)} };`;
|
|
|
|
const fn = new Function('store', code);
|
|
const allDefs = fn(store);
|
|
|
|
// Populate store
|
|
for (const [name, value] of Object.entries(allDefs)) {
|
|
if (name !== '__result') {
|
|
store[name] = value;
|
|
}
|
|
}
|
|
|
|
return allDefs.__result;
|
|
}
|
|
|
|
export function freeVars(ast: AST, bound: Set<string> = new Set()): Set<string> {
|
|
switch (ast.kind) {
|
|
case 'literal':
|
|
case 'constructor':
|
|
return new Set();
|
|
|
|
case 'variable':
|
|
return bound.has(ast.name) ? new Set() : new Set([ast.name]);
|
|
|
|
case 'lambda': {
|
|
const newBound = new Set([...bound, ...ast.params]);
|
|
return freeVars(ast.body, newBound);
|
|
}
|
|
|
|
case 'let': {
|
|
const valueVars = freeVars(ast.value, bound);
|
|
const bodyVars = freeVars(ast.body, new Set([...bound, ast.name]));
|
|
return new Set([...valueVars, ...bodyVars]);
|
|
}
|
|
|
|
case 'apply': {
|
|
const funcVars = freeVars(ast.func, bound);
|
|
const argVars = ast.args.flatMap(a => [...freeVars(a, bound)])
|
|
return new Set([...funcVars, ...argVars]);
|
|
}
|
|
|
|
case 'record': {
|
|
const allVars = ast.entries.flatMap(entry =>
|
|
entry.kind === 'spread'
|
|
? [...freeVars(entry.expr, bound)]
|
|
: [...freeVars(entry.value, bound)]
|
|
);
|
|
return new Set(allVars);
|
|
}
|
|
|
|
case 'list': {
|
|
const allVars = ast.elements.flatMap(e =>
|
|
'spread' in e ? [...freeVars(e.spread, bound)]
|
|
: [...freeVars(e, bound)]);
|
|
return new Set(allVars);
|
|
}
|
|
|
|
case 'record-access':
|
|
return freeVars(ast.record, bound);
|
|
|
|
case 'record-update': {
|
|
const recordVars = freeVars(ast.record, bound);
|
|
const updateVars = Object.values(ast.updates).flatMap(v => [...freeVars(v, bound)]);
|
|
return new Set([...recordVars, ...updateVars]);
|
|
}
|
|
|
|
case 'match': {
|
|
const exprVars = freeVars(ast.expr, bound);
|
|
const caseVars = ast.cases.flatMap(c => {
|
|
const patternBindings = patternVars(c.pattern);
|
|
const newBound = new Set([...bound, ...patternBindings]);
|
|
return [...freeVars(c.result, newBound)];
|
|
})
|
|
return new Set([...exprVars, ...caseVars]);
|
|
}
|
|
|
|
case 'rebind':
|
|
return freeVars(ast.value, bound);
|
|
|
|
default:
|
|
return new Set();
|
|
}
|
|
}
|
|
|
|
function patternVars(pattern: Pattern): string[] {
|
|
switch (pattern.kind) {
|
|
case 'var':
|
|
return [pattern.name];
|
|
case 'constructor':
|
|
return pattern.args.flatMap(patternVars);
|
|
case 'list':
|
|
return pattern.elements.flatMap(patternVars);
|
|
case 'list-spread':
|
|
return [...pattern.head.flatMap(patternVars), pattern.spread];
|
|
case 'record':
|
|
return Object.values(pattern.fields).flatMap(patternVars);
|
|
default:
|
|
return [];
|
|
}
|
|
|
|
}
|
|
|
|
export function recompile(name: string, newAst: AST) {
|
|
const existing = definitions.get(name);
|
|
definitions.set(name, { kind: 'definition', name, body: newAst, annotation: existing?.annotation });;
|
|
// definitions.set(name, newAst);
|
|
|
|
const topLevel = new Set(definitions.keys());
|
|
const free = freeVars(newAst);
|
|
const newDeps = new Set([...free].filter(v => topLevel.has(v)));
|
|
|
|
const oldDeps = dependencies.get(name) || new Set();
|
|
for (const dep of oldDeps) {
|
|
dependents.get(dep)?.delete(name);
|
|
}
|
|
|
|
for (const dep of newDeps) {
|
|
dependents.get(dep)?.add(name);
|
|
}
|
|
dependencies.set(name, newDeps);
|
|
|
|
const toRecompile: string[] = [];
|
|
const visited = new Set<string>();
|
|
|
|
function collectDependents(n: string) {
|
|
if (visited.has(n)) return;
|
|
visited.add(n);
|
|
toRecompile.push(n);
|
|
for (const dep of dependents.get(n) || []) {
|
|
collectDependents(dep);
|
|
}
|
|
}
|
|
collectDependents(name);
|
|
|
|
for (const defName of toRecompile) {
|
|
const ast = definitions.get(defName)!.body;
|
|
const compiled = compile(ast);
|
|
|
|
const fn = new Function('store', `return ${compiled}`);
|
|
store[defName] = fn(store);
|
|
}
|
|
}
|
|
|
|
function getRootName(ast: AST): string | null {
|
|
if (ast.kind === 'variable') return ast.name;
|
|
if (ast.kind === 'record-access') return getRootName(ast.record);
|
|
return null;
|
|
}
|
|
|
|
function getPath(ast: AST): string[] {
|
|
if (ast.kind === 'variable') return [];
|
|
if (ast.kind === 'record-access') {
|
|
return [...getPath(ast.record), ast.field];
|
|
}
|
|
return [];
|
|
}
|