rooklang 0.0.0-stage → 0.3.0

package/dist/checker/flow.js

@@ -0,0 +1,134 @@
+import { containsBreak } from "../walk.js";
+import { BIGINT, BOOL, isNullable, nonNull, NULL, NUMBER, STRING, typesEqual, union, unionMembers, } from "./types.js";
+// Control flow for the checker: how conditions narrow the types of variables, and which statements
+// execution never continues after.
+/** What a value of unknown type is after `typeof x == tag`. */
+const PRIMITIVE_TAGS = new Map([
+    ['string', STRING],
+    ['number', NUMBER],
+    ['bigint', BIGINT],
+    ['boolean', BOOL],
+]);
+/** What `typeof` gives for every value of a type, or `null` when it may give several things. */
+export function typeofTag(type) {
+    switch (type.kind) {
+        case 'string':
+        case 'number':
+        case 'bigint':
+            return type.kind;
+        case 'bool':
+            return 'boolean';
+        case 'literal':
+            return typeof type.value;
+        case 'function':
+        case 'component':
+        case 'classValue':
+            return 'function';
+        case 'object':
+            return type.call ? 'function' : 'object';
+        case 'class':
+        case 'array':
+        case 'tuple':
+        case 'null':
+            return 'object';
+        default:
+            return null;
+    }
+}
+/** The type after `typeof x == tag` is found true (`matches`) or false. */
+export function narrowByTypeof(type, tag, matches) {
+    const base = nonNull(type);
+    if (base.kind === 'any' || base.kind === 'unknown') {
+        if (!matches)
+            return null;
+        return PRIMITIVE_TAGS.get(tag) ?? null;
+    }
+    const kept = unionMembers(base).filter((member) => {
+        const memberTag = typeofTag(member);
+        return memberTag === null || (memberTag === tag) === matches;
+    });
+    // typeof null is "object".
+    const keepsNull = isNullable(type) && (tag === 'object') === matches;
+    return union(keepsNull ? [...kept, NULL] : kept);
+}
+/** `"all"`, `42` or `true` written in the code: its value, or `undefined` for other expressions. */
+export function literalValue(node) {
+    switch (node.kind) {
+        case 'StringLiteral':
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+            return node.value;
+        default:
+            return undefined;
+    }
+}
+/** A type without one literal value: what is left after `x != "all"`. */
+export function withoutLiteral(type, value) {
+    const kept = unionMembers(nonNull(type)).filter((member) => !(member.kind === 'literal' && member.value === value));
+    return union(isNullable(type) ? [...kept, NULL] : kept);
+}
+export function withNarrowing(flow, narrowing) {
+    const result = new Map(flow);
+    for (const [binding, type] of narrowing)
+        result.set(binding, type);
+    return result;
+}
+/** Narrowing that holds after both branches: the variables narrowed the same way in both. */
+export function mergeFlows(a, b) {
+    const result = new Map();
+    for (const [binding, type] of a) {
+        const other = b.get(binding);
+        if (other && typesEqual(type, other))
+            result.set(binding, type);
+    }
+    return result;
+}
+/** Go's terminating statements: execution never continues after them. */
+export function isTerminating(node) {
+    switch (node.kind) {
+        case 'ReturnStatement':
+        case 'ThrowStatement':
+            return true;
+        case 'BlockStatement': {
+            const last = node.body.at(-1);
+            return last !== undefined && isTerminating(last);
+        }
+        case 'IfStatement':
+            return (node.alternate !== null && isTerminating(node.consequent) && isTerminating(node.alternate));
+        case 'ForStatement':
+            return node.condition === null && !containsBreak(node.body.body);
+        case 'SwitchStatement':
+            return (node.cases.some((switchCase) => switchCase.tests.length === 0) &&
+                node.cases.every((switchCase) => {
+                    const last = switchCase.body.at(-1);
+                    return last !== undefined && isTerminating(last) && !containsBreak(switchCase.body);
+                }));
+        // A select runs one of its cases, waiting for one if there is no default.
+        case 'SelectStatement':
+            return node.cases.every((selectCase) => {
+                const last = selectCase.body.at(-1);
+                return last !== undefined && isTerminating(last) && !containsBreak(selectCase.body);
+            });
+        case 'TryStatement':
+            return ((isTerminating(node.block) && (!node.handler || isTerminating(node.handler.body))) ||
+                (node.finalizer !== null && isTerminating(node.finalizer)));
+        default:
+            return false;
+    }
+}
+/** Whether execution never continues after the statement, counting `break` and `continue`. */
+export function leaves(node) {
+    switch (node.kind) {
+        case 'BreakStatement':
+        case 'ContinueStatement':
+            return true;
+        case 'BlockStatement': {
+            const last = node.body.at(-1);
+            return last !== undefined && leaves(last);
+        }
+        case 'IfStatement':
+            return node.alternate !== null && leaves(node.consequent) && leaves(node.alternate);
+        default:
+            return isTerminating(node);
+    }
+}

package/dist/checker/forwarding.d.ts

@@ -0,0 +1,15 @@
+import type * as ast from '../ast.ts';
+import type { ComponentInfo } from './context.ts';
+import { MarkupChecker } from './markup.ts';
+import type { ObjectType } from './types.ts';
+/** The type of `attrs` in the body: it can only be spread. */
+export declare const ATTRIBUTES: ObjectType;
+export declare abstract class ForwardingChecker extends MarkupChecker {
+    /**
+     * An attribute of a use that is not a property: checked as an attribute of the element that
+     * `{...attrs}` is spread on. False when the component takes no attributes.
+     */
+    protected checkForwarded(attribute: ast.JsxAttribute, info: ComponentInfo, tag: string): boolean;
+    /** `...attrs` is spread on one element of markup the component creates once. */
+    protected checkAttrsSpreads(info: ComponentInfo): void;
+}

package/dist/checker/forwarding.js

@@ -0,0 +1,78 @@
+import { attrsParam, attrsSpreads, attrsTarget } from "../attrs.js";
+import { isComponentUse } from "../refs.js";
+import { isSvgElement } from "../svg.js";
+import { MarkupChecker } from "./markup.js";
+// Attributes passed on: `...attrs`, the last property of a component, takes the attributes of a
+// use that are not properties, and `{...attrs}` puts them on one element of the component. A use
+// is checked as if they were written on that element.
+/** The type of `attrs` in the body: it can only be spread. */
+export const ATTRIBUTES = {
+    kind: 'object',
+    name: 'Attributes',
+    members: new Map(),
+    call: null,
+};
+const WHERE = {
+    for: '{for}',
+    if: '{if}',
+    switch: '{switch}',
+    expression: 'an expression',
+    function: 'a function',
+    block: 'a block of the body',
+};
+export class ForwardingChecker extends MarkupChecker {
+    /**
+     * An attribute of a use that is not a property: checked as an attribute of the element that
+     * `{...attrs}` is spread on. False when the component takes no attributes.
+     */
+    checkForwarded(attribute, info, tag) {
+        if (!attrsParam(info.node))
+            return false;
+        const target = attrsTarget(info.node);
+        const name = attribute.name.name;
+        const { value } = attribute;
+        // The component itself reports a missing spread.
+        if (!target?.tag)
+            return true;
+        if (name.startsWith('bind:')) {
+            this.error(`${name} does not go through the attributes of <${tag}>`, attribute.name);
+        }
+        else if ((name === 'class' || name === 'style') && value !== null) {
+            // They are added to those of the element, so they cannot change.
+            if (value.kind !== 'StringLiteral') {
+                this.error(`${name} passed to <${tag}> is added to that of its element, so it is a string: ${name}="..."`, value);
+            }
+        }
+        else {
+            const element = target.tag.name;
+            const svg = isSvgElement(element, false);
+            this.checkAttribute(attribute, element, this.elementOf(element, svg), svg);
+        }
+        return true;
+    }
+    /** `...attrs` is spread on one element of markup the component creates once. */
+    checkAttrsSpreads(info) {
+        const param = attrsParam(info.node);
+        if (!param)
+            return;
+        const name = param.name.name;
+        const spreads = attrsSpreads(info.node);
+        if (info.node.htmlTag) {
+            this.error(`a web component cannot take ...${name}: its attributes are its own`, param);
+        }
+        else if (spreads.length === 0) {
+            this.error(`...${name} is not spread on an element; put it among the attributes of one, e.g. <button {...${name}}>`, param);
+        }
+        spreads.forEach(({ attribute, element, repeated }, i) => {
+            if (isComponentUse(element)) {
+                this.error(`{...${name}} goes on an element, not on <${element.tag.name}>: the attributes are those of an element`, attribute);
+            }
+            else if (repeated !== null) {
+                this.error(`{...${name}} is inside ${WHERE[repeated]}, which may create the element more than once; spread it on an element the component creates once`, attribute);
+            }
+            else if (i > 0) {
+                this.error(`...${name} is spread on another element already: the attributes go to one element`, attribute);
+            }
+        });
+    }
+}

package/dist/checker/functions.d.ts

@@ -0,0 +1,24 @@
+import type * as ast from '../ast.ts';
+import { type BindingKind, Scope, type Flow } from './context.ts';
+import { ControlFlowChecker } from './control-flow.ts';
+import { type FunctionType, type Type } from './types.ts';
+export declare abstract class FunctionChecker extends ControlFlowChecker {
+    /**
+     * Checks a function body and returns its result types: the declared ones, or those inferred from
+     * the `return` statements when `results` is `null`.
+     */
+    protected checkFunction(params: readonly ast.Parameter[], type: FunctionType, results: Type[] | null, body: ast.BlockStatement | ast.Expression, options?: {
+        isConstructor?: boolean;
+        isComponent?: boolean;
+        closure?: boolean;
+        paramKind?: BindingKind;
+        async?: boolean;
+        inspect?: (scope: Scope) => void;
+    }): Type[];
+    /** The body of `x => x * 2`. */
+    protected checkExpressionBody(body: ast.Expression, results: Type[] | null): Type[];
+    protected inferResults(returns: Type[][], body: ast.BlockStatement): Type[];
+    protected stableFlow(): Flow;
+    protected checkArrowFunction(node: ast.ArrowFunction, expected: Type | null): Type;
+    protected checkFuncExpression(node: ast.FuncExpression): Type;
+}

package/dist/checker/functions.js

@@ -0,0 +1,154 @@
+import { Scope } from "./context.js";
+import { ControlFlowChecker } from "./control-flow.js";
+import { isTerminating } from "./flow.js";
+import { isUntyped, callSignature } from "./helpers.js";
+import { awaitedResults, isPromise } from "./promise.js";
+import { commonType, containsTypeParam, func, nonNull, UNKNOWN, } from "./types.js";
+// Bodies of functions, arrow functions and func literals, and the results they return.
+export class FunctionChecker extends ControlFlowChecker {
+    /**
+     * Checks a function body and returns its result types: the declared ones, or those inferred from
+     * the `return` statements when `results` is `null`.
+     */
+    checkFunction(params, type, results, body, options = {}) {
+        const saved = { scope: this.scope, flow: this.flow, fn: this.fn };
+        const { async = false } = options;
+        // An async function returns a Promise: its body returns what the Promise gives.
+        const declared = async && results ? awaitedResults(results) : results;
+        const wrap = (types) => (async && !results ? [this.promiseOf(types)] : types);
+        this.scope = new Scope(this.scope);
+        // A closure keeps the narrowing of variables that cannot change before it runs.
+        this.flow = options.closure ? this.stableFlow() : new Map();
+        this.fn = {
+            results: declared,
+            returns: [],
+            isConstructor: options.isConstructor ?? false,
+            isComponent: options.isComponent ?? false,
+            isAsync: async,
+        };
+        try {
+            // A generic function: its type parameters are types in its body.
+            for (const typeParam of type.typeParams)
+                this.scope.types.set(typeParam.name, typeParam);
+            params.forEach((param, i) => this.declareValue(param.name, options.paramKind ?? 'param', type.params[i] ?? UNKNOWN));
+            if (body.kind === 'BlockStatement') {
+                this.checkStatementList(body.body, false);
+                options.inspect?.(this.scope);
+                if (declared && declared.length > 0 && !isTerminating(body)) {
+                    this.error('missing return at the end of the function', {
+                        start: body.end - 1,
+                        end: body.end,
+                    });
+                }
+                return results ?? wrap(this.inferResults(this.fn.returns, body));
+            }
+            const types = this.checkExpressionBody(body, declared);
+            return results ?? wrap(types);
+        }
+        finally {
+            this.scope = saved.scope;
+            this.flow = saved.flow;
+            this.fn = saved.fn;
+        }
+    }
+    /** The body of `x => x * 2`. */
+    checkExpressionBody(body, results) {
+        if (results === null || results.length === 0) {
+            const type = this.checkExpression(body, null);
+            if (results !== null)
+                return [];
+            return type.kind === 'tuple' ? type.types : type.kind === 'void' ? [] : [type];
+        }
+        if (results.length === 1) {
+            const type = this.checkValue(body, results[0] ?? null);
+            this.expectAssignable(type, results[0], body, ' in return');
+            return results;
+        }
+        const types = this.unpack(body, results.length, null, 'return');
+        types.forEach((type, i) => this.expectAssignable(type, results[i], body, ' in return'));
+        return results;
+    }
+    inferResults(returns, body) {
+        const first = returns[0];
+        if (first === undefined)
+            return [];
+        const results = [...first];
+        for (const types of returns.slice(1)) {
+            if (types.length !== results.length) {
+                this.error('return statements return different numbers of values', body);
+                return results;
+            }
+            types.forEach((type, i) => {
+                // Different types of returns make a union, as in TypeScript.
+                results[i] = commonType(results[i], type);
+            });
+        }
+        return results;
+    }
+    stableFlow() {
+        const flow = new Map();
+        for (const [binding, type] of this.flow) {
+            if (binding.kind === 'const' || !this.assigned.has(binding.name))
+                flow.set(binding, type);
+        }
+        return flow;
+    }
+    checkArrowFunction(node, expected) {
+        const context = expected ? callSignature(nonNull(expected)) : null;
+        // Callbacks passed to untyped JS functions get untyped parameters.
+        const untypedContext = expected !== null && isUntyped(nonNull(expected));
+        const params = node.params.map((param, i) => {
+            if (param.type)
+                return this.resolveType(param.type);
+            const fromContext = context ? (context.params[i] ?? context.rest) : null;
+            if (fromContext && !containsTypeParam(fromContext, this.inferring))
+                return fromContext;
+            if (untypedContext)
+                return nonNull(expected);
+            this.error(`cannot infer the type of parameter "${param.name.name}": add a type`, param);
+            return UNKNOWN;
+        });
+        // Known result types from the context are checked; otherwise they are inferred. Those of an
+        // async function must be a Promise.
+        const contextResults = context &&
+            context.results.length > 0 &&
+            !context.results.some((type) => containsTypeParam(type, this.inferring)) &&
+            (!node.async || (context.results.length === 1 && isPromise(context.results[0])))
+            ? context.results
+            : null;
+        const type = func(params, []);
+        const checkBody = () => {
+            const inferring = this.inferring;
+            this.inferring = new Set();
+            try {
+                return this.checkFunction(node.params, type, contextResults, node.body, {
+                    closure: true,
+                    async: node.async,
+                });
+            }
+            finally {
+                this.inferring = inferring;
+            }
+        };
+        // In the initializer of a variable that the body uses, the body can wait for the variable's
+        // type if the function's type is known without it: from the context, or a callback whose
+        // result is not used.
+        const knownResults = contextResults ?? (untypedContext || context?.results.length === 0 ? [] : null);
+        if (knownResults && !params.includes(UNKNOWN) && this.deferBody(node.body, checkBody)) {
+            type.results = node.async && !contextResults ? [this.promiseOf([])] : knownResults;
+            return type;
+        }
+        type.results = checkBody();
+        return type;
+    }
+    checkFuncExpression(node) {
+        const type = this.signature(node.params, node.results, node.async);
+        const checkBody = () => this.checkFunction(node.params, type, type.results, node.body, {
+            closure: true,
+            async: node.async,
+        });
+        if (!this.deferBody(node.body, checkBody))
+            checkBody();
+        return type;
+    }
+}

package/dist/checker/go-for.d.ts

@@ -0,0 +1,12 @@
+import type * as ast from '../ast.ts';
+import { LoopChecker } from './loops.ts';
+export declare abstract class GoForChecker extends LoopChecker {
+    protected checkForIn(node: ast.ForInStatement): void;
+    private checkGoFor;
+    /**
+     * The names that the body uses from around it: those of the module go to the worker module as
+     * with a function there; local ones are copied to each worker, so they must be data. Either way
+     * a worker has its own, so changes to them there would not come back.
+     */
+    private checkCaptures;
+}

package/dist/checker/go-for.js

@@ -0,0 +1,93 @@
+import { arrayName, arrayUses, loopParams } from "../go-for.js";
+import { recordCaptures } from "../goroutines.js";
+import { assignedNames, freeNames } from "../names.js";
+import { forEachChild } from "../walk.js";
+import { firstUse } from "./goroutines.js";
+import { LoopChecker } from "./loops.js";
+import { notCopied } from "./transfer.js";
+import { typedArrayOf, typeToString } from "./types.js";
+// `go for i, v in items { ... }`: the parts of an array or a typed array run as goroutines. Each
+// worker gets its part and copies of the local names that the body uses, so the body reaches the
+// array only through its own element, `items[i]`, and changes nothing else that would stay here.
+export class GoForChecker extends LoopChecker {
+    checkForIn(node) {
+        super.checkForIn(node);
+        if (node.go)
+            this.checkGoFor(node);
+    }
+    checkGoFor(node) {
+        const iterable = this.checkedTypes.get(node.iterable);
+        if (iterable && !isSplit(iterable)) {
+            if (iterable.kind !== 'unknown' && iterable.kind !== 'any') {
+                this.error(`"go for" splits an array among workers, but ${typeToString(iterable)} is not an array; loop over a []T or a typed array, e.g. "go for i, v in pixels { ... }"`, node.iterable);
+            }
+        }
+        else if (iterable) {
+            const reason = notCopied(iterable);
+            if (reason) {
+                this.error(`"go for" copies the parts of the array to workers, but ${reason}`, node.iterable);
+            }
+        }
+        const array = arrayName(node);
+        for (const use of arrayUses(node).others) {
+            this.error(node.key && node.key.name !== '_'
+                ? `"go for" gives each worker only its part of "${array}", so the body uses it only as ${array}[${node.key.name}]; read other elements from another array, e.g. "go for i, _ in out { out[i] = src[i] + src[i + 1] }"`
+                : `"go for" gives each worker only its part of "${array}", so the body uses it only as its own element; name the index to write it, e.g. "go for i, v in ${array} { ${array}[i] = v * 2 }"`, use);
+        }
+        this.checkCaptures(node, array);
+    }
+    /**
+     * The names that the body uses from around it: those of the module go to the worker module as
+     * with a function there; local ones are copied to each worker, so they must be data. Either way
+     * a worker has its own, so changes to them there would not come back.
+     */
+    checkCaptures(node, array) {
+        const captured = [];
+        const assigned = assignedNames(node.body);
+        const written = writtenNames(node.body);
+        for (const name of freeNames({ params: loopParams(node), body: node.body })) {
+            const binding = this.lookupValue(name);
+            if (name === array || !binding || binding === this.globals.values.get(name))
+                continue;
+            const at = firstUse(node.body, name) ?? node;
+            const module = binding === this.moduleScope.values.get(name);
+            const reason = module ? null : binding.type && notCopied(binding.type);
+            if (module)
+                this.checkReach('the body of "go for"', [name], at);
+            else
+                captured.push(name);
+            if (reason) {
+                this.error(`the body of "go for" runs in workers, which get a copy of "${name}", but ${reason}`, at);
+            }
+            else if (assigned.has(name)) {
+                this.error(`the body of "go for" runs in workers, which get a copy of "${name}", so changing it there does not change it here; write the results into the array of the loop, or send them through a channel`, at);
+            }
+            else if (written.has(name)) {
+                this.error(`the body of "go for" runs in workers, which get a copy of "${name}", so changing it there does not change it here; loop over the array you write, e.g. "go for i, _ in ${name} { ${name}[i] = ... }"`, at);
+            }
+        }
+        recordCaptures(node, captured);
+    }
+}
+/** An array or a typed array, which `go for` splits into parts. */
+function isSplit(type) {
+    return type.kind === 'array' || typedArrayOf(type) !== null;
+}
+/** The names whose elements or properties code writes: `out[i] = v`, `point.x++`. */
+function writtenNames(node, names = new Set()) {
+    const add = (target) => {
+        if (target.kind !== 'IndexExpression' && target.kind !== 'MemberExpression')
+            return;
+        let root = target;
+        while (root.kind === 'IndexExpression' || root.kind === 'MemberExpression')
+            root = root.object;
+        if (root.kind === 'Identifier')
+            names.add(root.name);
+    };
+    if (node.kind === 'AssignmentStatement')
+        node.targets.forEach(add);
+    else if (node.kind === 'IncDecStatement')
+        add(node.target);
+    forEachChild(node, (child) => writtenNames(child, names));
+    return names;
+}

package/dist/checker/goroutines.d.ts

@@ -0,0 +1,19 @@
+import type * as ast from '../ast.ts';
+import { CallChecker } from './calls.ts';
+import { type Type } from './types.ts';
+export declare abstract class GoroutineChecker extends CallChecker {
+    /** The functions already checked for what their code reaches, so each is reported once. */
+    private readonly reached;
+    protected checkGo(node: ast.GoExpression): Type;
+    /** A function declared at the top level of the module, or an imported name. */
+    private isModuleFunction;
+    /**
+     * The names that a literal uses from around it: those of the module go to the worker module as
+     * with a function there; local ones are copied to the worker, so they must be data, and changing
+     * a copy would not change them.
+     */
+    private checkLiteral;
+    protected checkReach(name: string, names: string[], node: ast.NodeBase): void;
+}
+/** The first place where code uses a name, for a message about it. */
+export declare function firstUse(node: ast.Node, name: string): ast.Identifier | null;

package/dist/checker/goroutines.js

@@ -0,0 +1,110 @@
+import { reach, recordCaptures } from "../goroutines.js";
+import { assignedNames, freeNames } from "../names.js";
+import { forEachChild } from "../walk.js";
+import { CallChecker } from "./calls.js";
+import { awaited } from "./promise.js";
+import { notCopied } from "./transfer.js";
+import { UNKNOWN } from "./types.js";
+// `go work(x)`: the call of a function of the module in a worker; `go func(x) { ... }(y)`: of a
+// function literal, which gets copies of the local names it uses. The worker gets copies of the
+// arguments and gives back a copy of the result, so both must be data that can be copied; and the
+// code of the function must not need what a worker does not have: the variables of the module and
+// a document.
+export class GoroutineChecker extends CallChecker {
+    /** The functions already checked for what their code reaches, so each is reported once. */
+    reached = new Set();
+    checkGo(node) {
+        const { call } = node;
+        const result = this.checkExpression(call, null);
+        const { callee } = call;
+        if (callee.kind !== 'FuncExpression' &&
+            (callee.kind !== 'Identifier' || !this.isModuleFunction(callee.name))) {
+            this.error('"go" calls a function declared at the top level of a module or imported, or a function literal: a worker has only those, e.g. "go work(x)" or "go func() { ... }()"', callee);
+            return UNKNOWN;
+        }
+        const name = callee.kind === 'Identifier' ? `"${callee.name}"` : 'the goroutine';
+        call.arguments.forEach((arg, i) => {
+            const value = arg.kind === 'SpreadElement' ? arg.argument : arg;
+            const type = this.checkedTypes.get(value);
+            const element = arg.kind === 'SpreadElement' && type?.kind === 'array' ? type.element : type;
+            const reason = element && notCopied(element);
+            if (reason) {
+                this.error(`${name} runs in a worker, which gets a copy of argument ${i + 1}, but ${reason}`, value);
+            }
+        });
+        // An async function gives what its Promise gives, once the worker has waited for it.
+        const value = awaited(result);
+        const results = value.kind === 'tuple' ? value.types : value.kind === 'void' ? [] : [value];
+        const reason = results.map((type) => notCopied(type)).find((found) => found !== null);
+        if (reason) {
+            this.error(`${name} runs in a worker, which sends back a copy of its result, but ${reason}`, node);
+        }
+        if (callee.kind === 'Identifier') {
+            if (!this.reached.has(callee.name)) {
+                this.reached.add(callee.name);
+                this.checkReach(name, [callee.name], node);
+            }
+        }
+        else {
+            this.checkLiteral(node, callee);
+        }
+        return this.promiseOf(results);
+    }
+    /** A function declared at the top level of the module, or an imported name. */
+    isModuleFunction(name) {
+        const binding = this.lookupValue(name);
+        return (binding !== undefined &&
+            binding === this.moduleScope.values.get(name) &&
+            (binding.kind === 'function' || binding.kind === 'import'));
+    }
+    /**
+     * The names that a literal uses from around it: those of the module go to the worker module as
+     * with a function there; local ones are copied to the worker, so they must be data, and changing
+     * a copy would not change them.
+     */
+    checkLiteral(node, literal) {
+        const captured = [];
+        const module = [];
+        const assigned = assignedNames(literal.body);
+        for (const name of freeNames(literal)) {
+            const binding = this.lookupValue(name);
+            if (!binding || binding === this.globals.values.get(name))
+                continue;
+            if (binding === this.moduleScope.values.get(name)) {
+                module.push(name);
+                continue;
+            }
+            captured.push(name);
+            const reason = binding.type && notCopied(binding.type);
+            const at = firstUse(literal.body, name) ?? node;
+            if (reason) {
+                this.error(`the goroutine runs in a worker, which gets a copy of "${name}", but ${reason}`, at);
+            }
+            else if (assigned.has(name)) {
+                this.error(`the goroutine runs in a worker, which gets a copy of "${name}", so changing it there does not change it here; send the new value through a channel or return it`, at);
+            }
+        }
+        recordCaptures(node, captured);
+        for (const name of module)
+            this.checkReach('the goroutine', [name], firstUse(literal.body, name) ?? node);
+    }
+    checkReach(name, names, node) {
+        const { lets, markup } = reach(this.program, names);
+        for (const variable of lets) {
+            this.error(`${name} runs in a worker, which does not share the variables of the module, but its code uses "${variable}"; pass the value as an argument, or make it a const`, node);
+        }
+        if (markup !== null) {
+            this.error(`${name} runs in a worker, which has no document, but its code uses ${markup}`, node);
+        }
+    }
+}
+/** The first place where code uses a name, for a message about it. */
+export function firstUse(node, name) {
+    if (node.kind === 'Identifier')
+        return node.name === name ? node : null;
+    let found = null;
+    forEachChild(node, (child) => {
+        found ??= firstUse(child, name);
+    });
+    return found;
+}