rooklang 0.0.0-stage → 0.3.0

package/dist/decorators.js

@@ -0,0 +1,241 @@
+import { renamer } from "./decorator-copy.js";
+import { declaredIn, freeNames, mentionsName, topLevelNames } from "./names.js";
+import { containsReturn } from "./recursion.js";
+import { forEachChild } from "./walk.js";
+// Applying decorators: a component with decorators becomes one component whose body runs the
+// bodies of its decorators first. The checker uses it to see what the inlined code uses, the
+// generator to write it.
+/** The JS name of a member or a parameter of a decorator, in the components it is applied to. */
+export function decoratedName(decorator, member) {
+    return `$$${decorator}$${member}`;
+}
+const argumentDeclarations = new WeakSet();
+const wrappedContents = new WeakSet();
+/**
+ * Whether a declaration of an applied component gets an argument of a decorator. When the
+ * argument reads the component's properties, the declaration is a `state` that the properties
+ * set again.
+ */
+export function isDecoratorArgument(node) {
+    return node.kind === 'VariableDeclaration' && argumentDeclarations.has(node);
+}
+/**
+ * Whether markup is what a component returns to the wrapper of a decorator, as in
+ * `const $$visible$content = <section>...</section>`: it updates like returned markup.
+ */
+export function isWrappedContent(node) {
+    return wrappedContents.has(node);
+}
+/** The markup that an applied component gives to the wrappers, whichever `return` it takes. */
+export function wrappedMarkup(component) {
+    const found = [];
+    const visit = (node) => {
+        if (node.kind === 'VariableDeclaration') {
+            found.push(...node.values.filter((value) => wrappedContents.has(value)));
+        }
+        forEachChild(node, visit);
+    };
+    visit(component.body);
+    return found;
+}
+/** The wrapper of a decorator, when it returns a function literal with one parameter. */
+export function wrapperOf(decorator) {
+    const last = decorator.body.body.at(-1);
+    const [fn] = last?.kind === 'ReturnStatement' ? last.values : [];
+    if (fn?.kind !== 'ArrowFunction' && fn?.kind !== 'FuncExpression')
+        return null;
+    const [param] = fn.params;
+    return param && fn.params.length === 1 ? { fn, param } : null;
+}
+/** The statements of a wrapper; an expression body is what it returns. */
+export function wrapperBody(fn) {
+    if (fn.body.kind === 'BlockStatement')
+        return fn.body.body;
+    return [{ kind: 'ReturnStatement', values: [fn.body], start: fn.body.start, end: fn.body.end }];
+}
+/** The parameter of a wrapper and its declarations, which go into the component's body too. */
+export function wrapperNames(wrapper) {
+    return [wrapper.param.name.name, ...declaredIn(wrapperBody(wrapper.fn))];
+}
+/**
+ * The names of its module that a decorator's code uses. Other modules that apply it get them
+ * through hidden exports: `export { log as $$visible$log }`.
+ */
+export function moduleNamesOf(decorator, program) {
+    const topLevel = topLevelNames(program);
+    return [...freeNames(decorator)].filter((name) => topLevel.has(name)).sort();
+}
+/**
+ * The component with its decorators applied. Its body first declares the arguments of each
+ * decorator and runs its body, from the top decorator down, then runs the component's own body.
+ * The names of a decorator get its prefix, `$$visible$shown`, so they clash neither with each other
+ * nor with the component's names, and `get(@visible.shown)` reads that variable. The `mount()` of
+ * the decorators runs after the component's own, from the inside out, so it goes before every
+ * `return` of the component's body.
+ *
+ * A wrapper is inlined at every `return` too: `return <section />` becomes
+ * `const $$visible$content = <section />`, then the body of the wrapper, whose `return` is the
+ * component's. The wrappers apply from the bottom decorator up.
+ *
+ * `prefixes` replace the names of decorators in the prefixes: a module that inlines a component of
+ * another one keeps the decorators of that module apart from its own, `$$Card$visible$shown`.
+ */
+export function decorate(component, decorators, copied, prefixes) {
+    if (component.decorators.length === 0)
+        return component;
+    const props = new Set(component.params.map((param) => param.name.name));
+    const setup = [];
+    const mounts = [];
+    const wrappers = [];
+    for (const use of component.decorators) {
+        const source = decorators.get(use.name.name);
+        if (!source)
+            continue;
+        const decorator = source.node;
+        const prefix = prefixes?.get(decorator.name.name) ?? decorator.name.name;
+        const names = [...decoratorNames(decorator), ...source.moduleNames];
+        const renames = membersOf(prefix, names);
+        const copy = renamer(renames, copied, { decorators: prefixes, tags: source.tags });
+        decorator.params.forEach((param, i) => {
+            // A default value is the decorator's code, an argument the component's.
+            const value = use.arguments[i] ?? (param.defaultValue && copy(param.defaultValue, new Set()));
+            const declaration = {
+                kind: 'VariableDeclaration',
+                exported: false,
+                isPublic: false,
+                keyword: value && mentionsName(value, props) ? 'state' : 'const',
+                names: [{ ...param.name, name: renames.get(param.name.name) }],
+                type: param.type,
+                values: value ? [value] : [],
+                start: param.start,
+                end: param.end,
+            };
+            argumentDeclarations.add(declaration);
+            copied?.(declaration, param);
+            setup.push(declaration);
+        });
+        const wrapper = wrapperOf(decorator);
+        const own = [];
+        for (const statement of decorator.body.body) {
+            if (wrapper && statement === decorator.body.body.at(-1))
+                continue;
+            const renamed = copy(statement, new Set());
+            if (renamed.kind === 'MountStatement')
+                own.push(renamed);
+            else
+                setup.push(renamed);
+        }
+        mounts.push(own);
+        if (wrapper)
+            wrappers.push(applyWrapper(source, wrapper, copied, prefix, prefixes));
+    }
+    const inside = mounts.reverse().flat();
+    const chain = wrappers.reverse();
+    const body = inside.length > 0 || chain.length > 0
+        ? mapReturns(component.body.body, (node) => [...inside, ...wrapped(node, chain)])
+        : component.body.body;
+    return {
+        ...component,
+        decorators: [],
+        body: { ...component.body, body: [...setup, ...body] },
+    };
+}
+/** The parameters of a decorator and the declarations of its body: the names it renames. */
+export function decoratorNames(decorator) {
+    const names = [
+        ...decorator.params.map((param) => param.name.name),
+        ...declaredIn(decorator.body.body),
+    ];
+    return new Set(names.filter((name) => name !== '_'));
+}
+function membersOf(prefix, names) {
+    const renames = new Map();
+    for (const name of names) {
+        if (name !== '_')
+            renames.set(name, decoratedName(prefix, name));
+    }
+    return renames;
+}
+/**
+ * The names of the wrapper's code are renamed too: it goes into the component's body. Outside the
+ * wrapper they are not the decorator's, so the rest of the body is copied without them.
+ */
+function applyWrapper(source, wrapper, copied, prefix, prefixes) {
+    const names = [...decoratorNames(source.node), ...source.moduleNames, ...wrapperNames(wrapper)];
+    const renames = membersOf(prefix, names);
+    const copy = renamer(renames, copied, { decorators: prefixes, tags: source.tags });
+    const { name } = wrapper.param;
+    return {
+        content: { ...name, name: renames.get(name.name) ?? name.name },
+        type: wrapper.param.type,
+        body: () => wrapperBody(wrapper.fn).map((statement) => copy(statement, new Set())),
+    };
+}
+/** A `return` of the component through the wrappers, the innermost first. */
+function wrapped(node, chain) {
+    const [wrapper, ...outer] = chain;
+    const [value] = node.values;
+    if (!wrapper || !value || node.values.length !== 1)
+        return [node];
+    wrappedContents.add(value);
+    const content = {
+        kind: 'VariableDeclaration',
+        exported: false,
+        isPublic: false,
+        keyword: 'const',
+        names: [{ ...wrapper.content }],
+        type: wrapper.type,
+        values: [value],
+        start: node.start,
+        end: node.end,
+    };
+    return [content, ...mapReturns(wrapper.body(), (inner) => wrapped(inner, outer))];
+}
+/** The statements with each `return` replaced; those of nested functions are their own. */
+function mapReturns(statements, replace) {
+    return statements.flatMap((statement) => statement.kind === 'ReturnStatement' ? replace(statement) : [withReplaced(statement, replace)]);
+}
+function withReplaced(statement, replace) {
+    if (!containsReturn(statement))
+        return statement;
+    const block = (node) => ({
+        ...node,
+        body: mapReturns(node.body, replace),
+    });
+    switch (statement.kind) {
+        case 'BlockStatement':
+            return block(statement);
+        case 'IfStatement': {
+            const { alternate } = statement;
+            return {
+                ...statement,
+                consequent: block(statement.consequent),
+                alternate: alternate === null
+                    ? null
+                    : alternate.kind === 'IfStatement'
+                        ? withReplaced(alternate, replace)
+                        : block(alternate),
+            };
+        }
+        case 'ForStatement':
+        case 'ForInStatement':
+            return { ...statement, body: block(statement.body) };
+        case 'SwitchStatement':
+            return {
+                ...statement,
+                cases: statement.cases.map((switchCase) => ({
+                    ...switchCase,
+                    body: mapReturns(switchCase.body, replace),
+                })),
+            };
+        case 'TryStatement':
+            return {
+                ...statement,
+                block: block(statement.block),
+                handler: statement.handler && { ...statement.handler, body: block(statement.handler.body) },
+                finalizer: statement.finalizer && block(statement.finalizer),
+            };
+        default:
+            return statement;
+    }
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,17 @@
+import type { SourceFile } from './source.ts';
+export interface Diagnostic {
+    message: string;
+    /** Offsets into the source text. */
+    start: number;
+    end: number;
+}
+/**
+ * Formats a diagnostic in the usual compiler style:
+ *
+ *     hello.rk:2:9: error: unterminated string literal
+ *     2 | let s = "abc
+ *       |         ^^^^
+ *
+ * Warnings do not stop compilation: `warning:` instead of `error:`.
+ */
+export declare function formatDiagnostic(file: SourceFile, diagnostic: Diagnostic, severity?: 'error' | 'warning'): string;

package/dist/diagnostics.js

@@ -0,0 +1,22 @@
+/**
+ * Formats a diagnostic in the usual compiler style:
+ *
+ *     hello.rk:2:9: error: unterminated string literal
+ *     2 | let s = "abc
+ *       |         ^^^^
+ *
+ * Warnings do not stop compilation: `warning:` instead of `error:`.
+ */
+export function formatDiagnostic(file, diagnostic, severity = 'error') {
+    const { line, column } = file.position(diagnostic.start);
+    const text = file.lineText(line);
+    // Keep tabs so that the caret lines up with the source line.
+    const indent = text.slice(0, column - 1).replace(/[^\t]/g, ' ');
+    const width = Math.max(1, Math.min(diagnostic.end - diagnostic.start, text.length - column + 1));
+    const gutter = ' '.repeat(String(line).length);
+    return [
+        `${file.name}:${line}:${column}: ${severity}: ${diagnostic.message}`,
+        `${line} | ${text}`,
+        `${gutter} | ${indent}${'^'.repeat(width)}`,
+    ].join('\n');
+}

package/dist/go-for.d.ts

@@ -0,0 +1,26 @@
+import type * as ast from './ast.ts';
+/** Whether a node is `go for`. */
+export declare function isGoFor(node: ast.Node): node is ast.ForInStatement;
+/** The array that the body may write into: the iterable, if it is a name. */
+export declare function arrayName(loop: ast.ForInStatement): string | null;
+/** The variables of the loop, as the parameters of a function, for the names its body uses. */
+export declare function loopParams(loop: ast.ForInStatement): ast.Parameter[];
+/** How the body uses the array: its own elements, `items[i]`, and anything else, an error. */
+export interface ArrayUses {
+    elements: ast.IndexExpression[];
+    others: ast.Identifier[];
+}
+/**
+ * The uses of the array in the body. A name declared again inside hides the array or the key; in
+ * a function literal of `go` the element is not the loop's, since that goroutine runs elsewhere.
+ */
+export declare function arrayUses(loop: ast.ForInStatement): ArrayUses;
+/** Whether the body writes into the array, so that the parts go back into it. */
+export declare function writesArray(loop: ast.ForInStatement, uses?: ArrayUses): boolean;
+/** The `go for` that a loop of a function of the worker module goes over a part of, or null. */
+export declare function partOf(node: ast.ForInStatement): ast.ForInStatement | null;
+/**
+ * The function of the worker module that runs a part of `go for`: it gets the part, the index of
+ * its first element in the array, and the local names that the body uses.
+ */
+export declare function partFunction(loop: ast.ForInStatement, name: string, captured: readonly string[]): ast.FuncDeclaration;

package/dist/go-for.js

@@ -0,0 +1,155 @@
+import { declaredIn, declaredNames } from "./names.js";
+import { forEachChild } from "./walk.js";
+// `go for i, v in items { ... }`: the array is split into parts, one per processor, each part runs
+// as a goroutine, and the loop waits for all of them. A goroutine is a function of the worker
+// module that loops over its part. The body reaches the array only through its own element,
+// `items[i]`, so the part is all that a goroutine needs: there `items` is the part, and `items[i]`
+// becomes `items[$$i]`, the index in the part. The local names that the body uses are copied to
+// the workers, as for a function literal of `go` (goroutines.ts).
+/** Whether a node is `go for`. */
+export function isGoFor(node) {
+    return node.kind === 'ForInStatement' && node.go === true;
+}
+/** The array that the body may write into: the iterable, if it is a name. */
+export function arrayName(loop) {
+    return loop.iterable.kind === 'Identifier' ? loop.iterable.name : null;
+}
+/** The variables of the loop, as the parameters of a function, for the names its body uses. */
+export function loopParams(loop) {
+    return [loop.key, loop.value].flatMap((name) => name
+        ? [
+            {
+                kind: 'Parameter',
+                name,
+                type: null,
+                defaultValue: null,
+                start: name.start,
+                end: name.end,
+            },
+        ]
+        : []);
+}
+/**
+ * The uses of the array in the body. A name declared again inside hides the array or the key; in
+ * a function literal of `go` the element is not the loop's, since that goroutine runs elsewhere.
+ */
+export function arrayUses(loop) {
+    const uses = { elements: [], others: [] };
+    const array = arrayName(loop);
+    const key = loop.key && loop.key.name !== '_' ? loop.key.name : null;
+    if (array === null)
+        return uses;
+    const visit = (node, keyShown) => {
+        const declared = scopeNames(node);
+        if (declared.has(array))
+            return;
+        const shown = keyShown && (key === null || !declared.has(key));
+        switch (node.kind) {
+            case 'Identifier':
+                if (node.name === array)
+                    uses.others.push(node);
+                return;
+            case 'IndexExpression':
+                if (shown &&
+                    !node.optional &&
+                    node.object.kind === 'Identifier' &&
+                    node.object.name === array &&
+                    node.index.kind === 'Identifier' &&
+                    node.index.name === key) {
+                    uses.elements.push(node);
+                    return;
+                }
+                break;
+            case 'MemberExpression':
+                visit(node.object, shown);
+                return;
+            case 'Property':
+                visit(node.value, shown);
+                return;
+            case 'GoExpression':
+                forEachChild(node, (child) => visit(child, false));
+                return;
+            default:
+                break;
+        }
+        forEachChild(node, (child) => visit(child, shown));
+    };
+    visit(loop.body, true);
+    return uses;
+}
+/** The names that a node declares for the code inside it. */
+function scopeNames(node) {
+    switch (node.kind) {
+        case 'FuncDeclaration':
+        case 'FuncExpression':
+        case 'ArrowFunction':
+        case 'ClassDeclaration':
+            return declaredNames(node);
+        case 'BlockStatement':
+            return new Set(declaredIn(node.body));
+        case 'ForInStatement':
+            return new Set([node.value.name, ...(node.key ? [node.key.name] : [])]);
+        case 'ForStatement':
+            return new Set(node.init?.kind === 'VariableDeclaration' ? declaredIn([node.init]) : []);
+        case 'SelectCase':
+            return new Set(node.names.map((name) => name.name));
+        case 'CatchClause':
+            return new Set(node.param ? [node.param.name] : []);
+        default:
+            return new Set();
+    }
+}
+/** Whether the body writes into the array, so that the parts go back into it. */
+export function writesArray(loop, uses = arrayUses(loop)) {
+    const elements = new Set(uses.elements);
+    let found = false;
+    const visit = (node) => {
+        if (node.kind === 'AssignmentStatement') {
+            found ||= node.targets.some((target) => elements.has(target));
+        }
+        else if (node.kind === 'IncDecStatement') {
+            found ||= elements.has(node.target);
+        }
+        forEachChild(node, visit);
+    };
+    visit(loop.body);
+    return found;
+}
+/** The loops in the functions of the worker module, by the `go for` they were made from. */
+const parts = new WeakMap();
+/** The `go for` that a loop of a function of the worker module goes over a part of, or null. */
+export function partOf(node) {
+    return parts.get(node) ?? null;
+}
+/**
+ * The function of the worker module that runs a part of `go for`: it gets the part, the index of
+ * its first element in the array, and the local names that the body uses.
+ */
+export function partFunction(loop, name, captured) {
+    const at = { start: loop.start, end: loop.start };
+    const id = (name) => ({ kind: 'Identifier', name, ...at });
+    const array = arrayName(loop) ?? '$$items';
+    const part = { ...loop, iterable: id(array) };
+    const params = [array, '$$from', ...captured].map((each) => ({
+        kind: 'Parameter',
+        name: id(each),
+        type: null,
+        defaultValue: null,
+        ...at,
+    }));
+    parts.set(part, loop);
+    return {
+        kind: 'FuncDeclaration',
+        exported: false,
+        isPublic: false,
+        // The body may wait, for a channel or for `go`.
+        async: true,
+        name: id(name),
+        typeParams: [],
+        params,
+        results: [],
+        body: { kind: 'BlockStatement', body: [part], start: loop.start, end: loop.end },
+        start: loop.start,
+        end: loop.end,
+    };
+}

package/dist/goroutines.d.ts

@@ -0,0 +1,37 @@
+import type * as ast from './ast.ts';
+/** What runs as a goroutine: the call of `go`, or the body of `go for`. */
+export type Goroutine = ast.GoExpression | ast.ForInStatement;
+/** What a goroutine reaches from the function it calls. */
+export interface Reach {
+    /** Top-level declarations of the module, in source order. */
+    statements: ast.Statement[];
+    /** Imported names, by their import declarations. */
+    imports: Map<ast.ImportDeclaration, Set<string>>;
+    /** `let` variables of the module: a worker does not share them. */
+    lets: string[];
+    /** Components, decorators or markup, which need a document: the first one found. */
+    markup: string | null;
+}
+/** Every `go` expression and `go for` loop of the program, nested ones too. */
+export declare function goroutines(program: ast.Program): Goroutine[];
+/**
+ * The function that a goroutine calls in the worker module: a name, or the name given to a
+ * function literal or a `go for`; anything else is reported by the checker.
+ */
+export declare function goTarget(program: ast.Program, node: Goroutine): string | null;
+export declare function recordCaptures(node: Goroutine, names: string[]): void;
+/**
+ * The local names that the literal of a `go` or a `go for` gets first: those the checker found.
+ * Code that was not checked passes the names that the code uses and the declaration around it
+ * declares, but not the array of `go for`, which goes in parts.
+ */
+export declare function goCaptures(program: ast.Program, node: Goroutine): string[];
+/** Parameters for the local names that a literal of `go` gets first. */
+export declare function goParams(literal: ast.FuncExpression, names: string[]): ast.Parameter[];
+/** What the code of the functions `names` reaches in the module, through the names it uses. */
+export declare function reach(program: ast.Program, names: Iterable<string>): Reach;
+/**
+ * The program of the worker module: the imports and the declarations that the functions `targets`
+ * reach, unexported, since the worker module is only loaded by the worker.
+ */
+export declare function workerProgram(program: ast.Program, targets: readonly string[]): ast.Program;