@scriptc/compiler 0.4.6 → 0.4.8

package/dist/backend/tree-classes.js

@@ -0,0 +1,723 @@
+import { everyExprChild, everyStmtChild } from "../ir/traverse.js";
+import { computeTraced } from "./cycle-analysis.js";
+import { constructorEscapePoint } from "./cycle-mutability.js";
+import { computeImmutableFields } from "./immutability.js";
+import { computePublishedTypes } from "./publication.js";
+/** Every class name that passes both analyses, plus one rejection reason
+ * list per class name that was considered. Pure: reads `mod` only. */
+export function planTreeClasses(mod, facts) {
+    const rejected = new Map();
+    const classes = new Set();
+    const moves = new Set();
+    if (mod.lib !== undefined)
+        return { classes, moves, rejected };
+    const defs = mod.classes ?? [];
+    const unions = new Map((mod.unions ?? []).map((u) => [u.id, u]));
+    const functions = new Map(mod.functions.map((fn) => [fn.name, fn]));
+    const traced = facts.traced ?? computeTraced(mod);
+    const immutable = facts.immutable !== undefined ? facts.immutable : computeImmutableFields(mod);
+    const published = facts.published !== undefined ? facts.published : computePublishedTypes(mod);
+    const lifetime = new Set(mod.contracts?.programLifetime ?? []);
+    const bases = new Set(defs.flatMap((d) => (d.base === undefined ? [] : [d.base])));
+    const slots = collectTypeSlots(mod);
+    for (const def of defs) {
+        if (def.runtime === true)
+            continue;
+        const name = def.name;
+        const reasons = [];
+        const reject = (why) => {
+            if (reasons.length < 4)
+                reasons.push(why);
+        };
+        const finish = () => {
+            if (reasons.length === 0)
+                classes.add(name);
+            else
+                rejected.set(name, reasons);
+        };
+        // ── Analysis A: the shape of the class itself ───────────────────────
+        if (def.base !== undefined || bases.has(name))
+            reject("is part of a hierarchy");
+        if (def.arrayElem !== undefined)
+            reject("extends Array");
+        if (def.localCaptures !== undefined)
+            reject("is declared inside a function");
+        if (lifetime.has(name))
+            reject("implements ProgramLifetime");
+        if (def.fields.length === 0)
+            reject("declares no fields");
+        if (traced.shapes.has(`object:${name}`))
+            reject("is on a cycle or reaches one");
+        if (published?.classGuarded(name) === true)
+            reject("is published to package code");
+        if (mod.declBoundary === true)
+            reject("the module boxes values at declaration boundaries");
+        if (reasons.length > 0) {
+            finish();
+            continue;
+        }
+        // Reference fields must be written by the constructor alone: a node
+        // that can be rewired after construction can gain a second owner.
+        for (const field of def.fields) {
+            if (!mentions(field.type, name, unions))
+                continue;
+            if (immutable?.classField(name, field.name) !== true)
+                reject(`field ${field.name} is written after construction`);
+        }
+        // Only a constructor that never lets `this` out can be a node: every
+        // other path out of it would give the object a second owner.
+        const ctor = functions.get(`%${name}.constructor`);
+        if (ctor === undefined)
+            reject("has no constructor body");
+        else {
+            const thisId = ctor.params[0]?.localId;
+            if (thisId === undefined)
+                reject("has a constructor without this");
+            else if (constructorEscaped(ctor, thisId, null))
+                reject("its constructor lets this escape");
+            // A constructor whose body owns its `this` releases it on exit, which
+            // would destroy an instance its `new` expression still owns.
+            if (facts.borrowed.get(`%${name}.constructor`)?.has(0) !== true)
+                reject("its constructor body owns this");
+        }
+        // ── Analysis A: every type in the module that mentions the class ────
+        for (const slot of slots) {
+            if (!mentions(slot.type, name, unions))
+                continue;
+            const shape = treeShape(slot.type, name, unions);
+            if (shape === null) {
+                reject(`${slot.where} holds it in a type that is neither the class nor null or it`);
+                continue;
+            }
+            if (shape === "nullable" && traced.unions.has(unionIdOf(slot.type))) {
+                reject(`${slot.where} boxes it in a union that can reach a cycle`);
+                continue;
+            }
+            if (!treeSlot(slot, name))
+                reject(`${slot.where} lets a reference escape the tree discipline`);
+        }
+        if (reasons.length > 0) {
+            finish();
+            continue;
+        }
+        // ── Analysis B: whole-program linear use ───────────────────────────
+        const check = new LinearUse(name, unions, functions, facts);
+        for (const fn of mod.functions)
+            check.function(fn);
+        for (const why of check.reasons())
+            reject(why);
+        finish();
+        if (classes.has(name))
+            for (const move of check.moves())
+                moves.add(move);
+    }
+    return { classes, moves, rejected };
+}
+function treeSlot(slot, name) {
+    switch (slot.slot) {
+        // Values in flight: parameters arrive owned or borrowed, locals hold an
+        // owner for their scope, and a result leaves through a move.
+        case "expr":
+        case "param":
+        case "local":
+        case "result":
+            return true;
+        // Only the class's own fields may point at its nodes. Another class or
+        // record field would be a second owner the destroy walk cannot follow
+        // (it walks one shape), so the class stays counted.
+        case "classField":
+            return slot.owner === name;
+        case "recordField":
+        case "global":
+        case "capture":
+            return false;
+    }
+}
+/** `object:C`, `C | null`, or null when the type is anything else. */
+function treeShape(type, name, unions) {
+    if (type.kind === "object")
+        return type.className === name ? "object" : null;
+    if (type.kind !== "union")
+        return null;
+    const arms = unions.get(type.unionId)?.arms;
+    if (arms === undefined || arms.length !== 2)
+        return null;
+    let object = false;
+    let nulled = false;
+    for (const arm of arms) {
+        if (arm.kind === "nullT")
+            nulled = true;
+        else if (arm.kind === "object" && arm.className === name)
+            object = true;
+        else
+            return null;
+    }
+    return object && nulled ? "nullable" : null;
+}
+function unionIdOf(type) {
+    return type.kind === "union" ? type.unionId : "";
+}
+/** Whether a value of this type can lead to an instance of `name`: directly,
+ * through a union arm, or through a container, closure or generator slot. */
+export function mentions(type, name, unions) {
+    switch (type.kind) {
+        case "object":
+        case "classval":
+            return type.className === name;
+        case "union": {
+            const arms = unions.get(type.unionId)?.arms;
+            return arms !== undefined && arms.some((arm) => mentions(arm, name, unions));
+        }
+        case "array":
+            return mentions(type.elem, name, unions);
+        case "map":
+            return mentions(type.key, name, unions) || mentions(type.value, name, unions);
+        case "set":
+            return mentions(type.elem, name, unions);
+        case "promise":
+            return mentions(type.inner, name, unions);
+        case "func":
+            return (type.params.some((param) => mentions(param, name, unions)) ||
+                mentions(type.ret, name, unions));
+        case "generator":
+            return (mentions(type.yieldT, name, unions) ||
+                mentions(type.retT, name, unions) ||
+                mentions(type.nextT, name, unions));
+        case "record":
+            return false;
+        default:
+            return false;
+    }
+}
+/** Whether `this` leaves the constructor for anywhere but a field of the
+ * object under construction. cycle-mutability's escape point is the index
+ * of the first body statement after which it did, so only a whole-body
+ * answer means it never did. */
+function constructorEscaped(fn, thisId, baseCtor) {
+    return constructorEscapePoint(fn, thisId, baseCtor) < fn.body.length;
+}
+const MAX_REASONS = 4;
+/** Linear use, one class at a time, over every function in the module.
+ * State is per local and per straight-line region; branch and loop bodies
+ * must leave the state of the locals they did not declare unchanged. */
+class LinearUse {
+    cls;
+    unions;
+    functions;
+    facts;
+    found = [];
+    treeLocals = new Map();
+    moved = [];
+    fn = null;
+    constructor(cls, unions, functions, facts) {
+        this.cls = cls;
+        this.unions = unions;
+        this.functions = functions;
+        this.facts = facts;
+    }
+    reasons() {
+        return this.found;
+    }
+    /** The varRef reads that took a node out of a local (see TreeClassPlan). */
+    moves() {
+        return this.moved;
+    }
+    fail(what) {
+        if (this.found.length < MAX_REASONS) {
+            this.found.push(`${this.fn?.name ?? "module"}: ${what}`);
+        }
+        return null;
+    }
+    tree(type) {
+        return mentions(type, this.cls, this.unions);
+    }
+    function(fn) {
+        this.fn = fn;
+        this.treeLocals.clear();
+        for (const local of fn.locals)
+            if (this.tree(local.type))
+                this.treeLocals.set(local.id, local);
+        // A function with no tree local and no tree result can still build or
+        // read a node inside an expression; walk it when the body mentions the
+        // class so the temporary rules reject the class instead of letting the
+        // lowering copy a value this analysis never saw moved.
+        if (this.treeLocals.size === 0 &&
+            !this.tree(fn.returnType) &&
+            !fn.body.some((stmt) => this.holdsTree(stmt)))
+            return;
+        if (fn.generator !== undefined) {
+            this.fail("a generator holds it");
+            return;
+        }
+        if (this.tree(fn.returnType)) {
+            const borrowed = this.facts.borrowedReturns;
+            if (borrowed?.has(fn.name) === true)
+                this.fail("returns a node it only borrows");
+        }
+        for (const capture of [...(fn.captures ?? []), ...(fn.classCaptures ?? [])])
+            if (this.tree(capture.type))
+                this.fail("a closure captures it");
+        const params = new Set(fn.params.map((param) => param.localId));
+        const ctorThis = fn.name === `%${this.cls}.constructor` ? fn.params[0]?.localId : undefined;
+        // A tree local that a later assignment could rebind needs the store
+        // path the lowering does not have; parameters are the exception, since
+        // their binding never changes.
+        for (const local of this.treeLocals.values())
+            if (!params.has(local.id) && local.mutable)
+                this.fail(`local ${local.id} is rebound`);
+        const state = new Map();
+        const borrowedParams = this.facts.borrowed.get(fn.name);
+        for (const [index, param] of fn.params.entries()) {
+            if (!this.tree(param.type))
+                continue;
+            // A parameter the callee borrows is a read-only view; one it owns is
+            // released at exit unless the body moves it on.
+            state.set(param.localId, param.localId === ctorThis
+                ? "borrowed"
+                : this.pending(param, fn)
+                    ? "pending"
+                    : borrowedParams?.has(index) === true
+                        ? "borrowed"
+                        : "owned");
+        }
+        if (!this.statements(fn.body, state))
+            return;
+        // The `new` expression hands each constructor argument over as an
+        // owned child; a parameter the body never stores in a field would leak
+        // the subtree it points at.
+        for (const [id, held] of state)
+            if (held === "pending")
+                this.fail(`constructor parameter ${id} is never stored`);
+    }
+    /** A constructor parameter other than `this` arrives owned by the new
+     * object: the body stores it in a field or destroys it. */
+    pending(param, fn) {
+        return fn.name === `%${this.cls}.constructor` && param.localId !== fn.params[0]?.localId;
+    }
+    statements(list, state) {
+        for (const stmt of list)
+            if (!this.statement(stmt, state))
+                return false;
+        return true;
+    }
+    statement(stmt, state) {
+        switch (stmt.kind) {
+            case "varDecl": {
+                if (!this.tree(this.treeLocals.get(stmt.localId)?.type ?? NO_TYPE)) {
+                    return stmt.init === null ? true : this.expr(stmt.init, "borrow", state) !== null;
+                }
+                if (stmt.init === null)
+                    return this.fail(`local ${stmt.localId} is declared without a value`) !== null;
+                const provenance = this.expr(stmt.init, "move", state);
+                if (provenance === null)
+                    return false;
+                if (provenance === "borrowed")
+                    return this.fail(`local ${stmt.localId} aliases a node it does not own`) !== null;
+                state.set(stmt.localId, "owned");
+                return true;
+            }
+            case "assign": {
+                if (this.treeLocals.has(stmt.localId) || this.tree(stmt.value.type))
+                    return this.fail("a tree local is assigned a second value") !== null;
+                return this.expr(stmt.value, "borrow", state) !== null;
+            }
+            case "exprStmt": {
+                // A statement that drops its value keeps only what it allocated;
+                // a node read out of a local or a field would be destroyed while
+                // its owner still holds it.
+                const provenance = this.expr(stmt.expr, "borrow", state);
+                if (provenance === null)
+                    return false;
+                if (provenance === "fresh" || provenance === "none")
+                    return true;
+                return this.fail("drops a node it does not own") !== null;
+            }
+            case "if": {
+                if (!this.borrowOnly(stmt.cond, state))
+                    return false;
+                const then = new Map(state);
+                if (!this.statements(stmt.then, then))
+                    return false;
+                const otherwise = stmt.else_ === null ? state : new Map(state);
+                if (stmt.else_ !== null && !this.statements(stmt.else_, otherwise))
+                    return false;
+                return this.join(state, then, otherwise);
+            }
+            case "block":
+                return this.statements(stmt.body, state);
+            case "while":
+            case "doWhile": {
+                if (stmt.kind === "while" && !this.borrowOnly(stmt.cond, state))
+                    return false;
+                const body = new Map(state);
+                if (!this.statements(stmt.body, body))
+                    return false;
+                if (stmt.kind === "doWhile" && !this.borrowOnly(stmt.cond, body))
+                    return false;
+                return this.join(state, state, body);
+            }
+            case "for": {
+                const body = new Map(state);
+                if (stmt.init !== null && !this.statement(stmt.init, body))
+                    return false;
+                if (stmt.cond !== null && !this.borrowOnly(stmt.cond, body))
+                    return false;
+                if (stmt.update !== null && !this.statement(stmt.update, body))
+                    return false;
+                if (!this.statements(stmt.body, body))
+                    return false;
+                return this.join(state, state, body);
+            }
+            case "switch": {
+                // A discriminant is compared by value; a node has no such compare.
+                if (this.tree(stmt.disc.type))
+                    return this.fail("switches on a node") !== null;
+                if (!this.borrowOnly(stmt.disc, state))
+                    return false;
+                for (const arm of stmt.cases) {
+                    if (arm.test !== null && this.tree(arm.test.type))
+                        return this.fail("compares a node in a case label") !== null;
+                    if (arm.test !== null && !this.borrowOnly(arm.test, state))
+                        return false;
+                    const body = new Map(state);
+                    if (!this.statements(arm.body, body))
+                        return false;
+                    if (!this.join(state, state, body))
+                        return false;
+                }
+                return true;
+            }
+            case "forOf": {
+                if (this.tree(stmt.iterable.type))
+                    return this.fail("iterates a value that holds it") !== null;
+                if (!this.expr(stmt.iterable, "borrow", state))
+                    return false;
+                const body = new Map(state);
+                if (!this.statements(stmt.body, body))
+                    return false;
+                return this.join(state, state, body);
+            }
+            case "fieldSet": {
+                if (!this.expr(stmt.obj, "borrow", state))
+                    return false;
+                if (!this.tree(stmt.value.type))
+                    return this.expr(stmt.value, "borrow", state) !== null;
+                const provenance = this.expr(stmt.value, "move", state);
+                if (provenance === null)
+                    return false;
+                if (provenance === "borrowed")
+                    return (this.fail(`field ${stmt.field} takes a node from a field it does not own`) !== null);
+                return true;
+            }
+            case "return": {
+                if (stmt.value === null || !this.tree(stmt.value.type))
+                    return stmt.value === null || this.expr(stmt.value, "borrow", state) !== null;
+                if (!this.tree(this.fn?.returnType ?? NO_TYPE))
+                    return this.fail("returns a node from a function that does not declare one") !== null;
+                const provenance = this.expr(stmt.value, "move", state);
+                if (provenance === null)
+                    return false;
+                if (provenance === "borrowed")
+                    return this.fail("returns a node it only borrows") !== null;
+                return true;
+            }
+            case "throw":
+                if (this.tree(stmt.value.type))
+                    return this.fail("throws a node") !== null;
+                return this.expr(stmt.value, "borrow", state) !== null;
+            case "tryCatch":
+                // A catch, a finally or a disposal can run with a partially
+                // transferred owner; the store path the lowering adds does not
+                // unwind. Keep the class counted instead.
+                if (this.holdsTree(stmt))
+                    return this.fail("a try statement holds one") !== null;
+                return true;
+            case "recordSet":
+            case "recordKeySet":
+            case "recordKeyDelete":
+            case "arraySet":
+            case "arraySetLength":
+            case "arraySetUndefined":
+            case "arrayDelete":
+            case "bytesSet":
+                if (this.holdsTree(stmt))
+                    return this.fail(`a ${stmt.kind} holds one`) !== null;
+                return true;
+            default:
+                // Everything else either touches no tree value or does so in a
+                // position this analysis does not model.
+                return this.holdsTree(stmt)
+                    ? this.fail(`a ${stmt.kind} statement holds one`) !== null
+                    : true;
+        }
+    }
+    /** Branch or loop merge: the state of every local that existed before the
+     * region must be the same on every path out of it. The agreed state becomes
+     * the state after the region, so a local both branches moved stays moved.
+     * Locals the region declared are scoped to it (each iteration allocates a
+     * fresh object). */
+    join(before, a, b) {
+        for (const [id, was] of before) {
+            const left = a.get(id) ?? was;
+            const right = b.get(id) ?? was;
+            if (left === right) {
+                before.set(id, left);
+                continue;
+            }
+            return this.fail(`local ${id} is transferred on only one path`) !== null;
+        }
+        return true;
+    }
+    borrowOnly(expr, state) {
+        return this.expr(expr, "borrow", state) !== null;
+    }
+    expr(expr, mode, state) {
+        switch (expr.kind) {
+            case "varRef": {
+                if (!this.tree(expr.type))
+                    return "none";
+                const held = state.get(expr.localId);
+                if (held === undefined || held === "moved")
+                    return this.fail(`local ${expr.localId} is used after it was moved`);
+                if (mode === "borrow")
+                    return held === "pending" ? "borrowed" : held;
+                if (held === "borrowed")
+                    return this.fail(`local ${expr.localId} is moved but only borrowed`);
+                this.moved.push(expr);
+                state.set(expr.localId, "moved");
+                return held === "pending" ? "pending" : "owned";
+            }
+            case "new": {
+                const involves = this.tree(expr.type) || expr.args.some((arg) => this.tree(arg.type));
+                if (!involves) {
+                    for (const arg of expr.args)
+                        if (!this.borrowOnly(arg, state))
+                            return null;
+                    return "none";
+                }
+                if (expr.className !== this.cls)
+                    return this.fail(`another class's constructor, ${expr.className}, holds it`);
+                for (const arg of expr.args) {
+                    if (!this.tree(arg.type)) {
+                        if (!this.borrowOnly(arg, state))
+                            return null;
+                        continue;
+                    }
+                    const provenance = this.expr(arg, "move", state);
+                    if (provenance === null)
+                        return null;
+                    if (provenance === "borrowed")
+                        return this.fail(`an argument from a field becomes a second owner`);
+                }
+                return "fresh";
+            }
+            case "call": {
+                const consumes = expr.args.some((arg) => this.tree(arg.type));
+                if (!this.tree(expr.type) && !consumes) {
+                    for (const arg of expr.args)
+                        if (!this.borrowOnly(arg, state))
+                            return null;
+                    return "none";
+                }
+                const callee = this.functions.get(expr.callee);
+                if (callee === undefined)
+                    return this.fail(`callee ${expr.callee} is not a module function`);
+                // A borrowed-return helper hands back a reference it does not own;
+                // the caller would treat it as a fresh node.
+                if (this.tree(expr.type) && this.facts.borrowedReturns?.has(expr.callee) === true)
+                    return this.fail(`callee ${expr.callee} lends the node it returns`);
+                const borrowed = this.facts.borrowed.get(expr.callee);
+                for (let i = 0; i < expr.args.length; i++) {
+                    const arg = expr.args[i];
+                    if (!this.tree(arg.type)) {
+                        if (!this.borrowOnly(arg, state))
+                            return null;
+                        continue;
+                    }
+                    const borrows = borrowed?.has(i) === true;
+                    const provenance = this.expr(arg, borrows ? "borrow" : "move", state);
+                    if (provenance === null)
+                        return null;
+                    if (!borrows && provenance === "borrowed")
+                        return this.fail(`callee ${expr.callee} consumes a node that comes from a field`);
+                }
+                return this.tree(expr.type) ? "fresh" : "none";
+            }
+            case "fieldGet": {
+                if (this.tree(expr.obj.type)) {
+                    const provenance = this.expr(expr.obj, "borrow", state);
+                    if (provenance === null)
+                        return null;
+                    if (provenance === "fresh")
+                        return this.fail(`field ${expr.field} is read from a node the statement owns`);
+                }
+                else if (!this.borrowOnly(expr.obj, state))
+                    return null;
+                return this.tree(expr.type) ? "borrowed" : "none";
+            }
+            // Wrappers that move no ownership: unboxing, narrowing, upcasts and
+            // the tag test of a nullable slot.
+            case "unionWrap":
+            case "unionNarrow":
+            case "upcast":
+                if (expr.value.kind === "unitLit")
+                    return "none";
+                return this.expr(expr.value, mode, state);
+            case "unionIsTag": {
+                const provenance = this.expr(expr.value, "borrow", state);
+                return provenance === null ? null : "none";
+            }
+            // Arithmetic and condition combining: the operands are read, never
+            // moved, and the result is a scalar.
+            case "logical":
+                if (!this.borrowOnly(expr.left, state) || !this.borrowOnly(expr.right, state))
+                    return null;
+                return "none";
+            case "bin":
+                if (this.tree(expr.type))
+                    return this.fail("an operator produces it");
+                if (!this.borrowOnly(expr.left, state) || !this.borrowOnly(expr.right, state))
+                    return null;
+                return "none";
+            // Scalar operations over values that may be computed from a node
+            // (`nodeCount(build(d))`): the operands are read and the result is a
+            // number, a string or a bool. None of these can retain a node.
+            case "toString":
+                if (this.tree(expr.operand.type))
+                    return this.fail("converts a node to text");
+                return this.borrowOnly(expr.operand, state) ? "none" : null;
+            case "strConcat":
+            case "strEq":
+            case "strCmp":
+                if (!this.borrowOnly(expr.left, state) || !this.borrowOnly(expr.right, state))
+                    return null;
+                return "none";
+            case "intrinsic":
+            case "libCall":
+                for (const arg of expr.args) {
+                    if (this.tree(arg.type))
+                        return this.fail(`a ${expr.kind} takes a node by value`);
+                    if (!this.borrowOnly(arg, state))
+                        return null;
+                }
+                return this.tree(expr.type) ? this.fail(`a ${expr.kind} produces one`) : "none";
+            case "seqExpr": {
+                for (const stmt of expr.stmts)
+                    if (!this.statement(stmt, state))
+                        return null;
+                return this.expr(expr.result, mode, state);
+            }
+            case "unitLit":
+                return "none";
+            default:
+                return this.holdsTree(expr) ? this.fail(`a ${expr.kind} expression holds one`) : "none";
+        }
+    }
+    /** Whether the value or any value inside it can reach a node. */
+    holdsTree(node) {
+        let found = false;
+        const exprVisitor = (e) => {
+            if (this.tree(e.type)) {
+                found = true;
+                return false;
+            }
+            return everyExprChild(e, exprVisitor, stmtVisitor);
+        };
+        const stmtVisitor = (s) => !found && everyStmtChild(s, exprVisitor, stmtVisitor);
+        if (isExpr(node))
+            exprVisitor(node);
+        else
+            everyStmtChild(node, exprVisitor, stmtVisitor);
+        return found;
+    }
+}
+const NO_TYPE = { kind: "void" };
+/** Every kind of the IR's statement union, which is the only list of them:
+ * the traversal walks anything else as an expression, so a statement kind
+ * missing here reaches `everyExprChild` as an expression and throws. */
+const STATEMENT_KINDS = new Set([
+    "varDecl",
+    "assign",
+    "exprStmt",
+    "if",
+    "while",
+    "doWhile",
+    "for",
+    "forOf",
+    "switch",
+    "block",
+    "return",
+    "throw",
+    "tryCatch",
+    "break",
+    "continue",
+    "genBindBarrier",
+    "rethrow",
+    "runtimeFence",
+    "fieldSet",
+    "recordSet",
+    "recordKeySet",
+    "recordKeyDelete",
+    "arraySet",
+    "arraySetLength",
+    "arraySetUndefined",
+    "arrayDelete",
+    "bytesSet",
+]);
+function isExpr(node) {
+    return !STATEMENT_KINDS.has(node.kind);
+}
+/** Every typed slot of the module, with where it sits. Root types only:
+ * `mentions` looks through the containers itself. */
+function collectTypeSlots(mod) {
+    const slots = [];
+    const add = (type, where, slot, owner) => {
+        slots.push(owner === undefined ? { type, where, slot } : { type, where, slot, owner });
+    };
+    for (const fn of mod.functions) {
+        for (const param of fn.params)
+            add(param.type, `${fn.name} parameter ${param.name}`, "param");
+        add(fn.returnType, `${fn.name} result`, "result");
+        for (const local of fn.locals)
+            add(local.type, `${fn.name} local ${local.name}`, "local");
+        for (const capture of fn.captures ?? [])
+            add(capture.type, `${fn.name} capture ${capture.name}`, "capture");
+        for (const capture of fn.classCaptures ?? [])
+            add(capture.type, `${fn.name} class capture ${capture.name}`, "capture");
+        if (fn.generator !== undefined) {
+            add(fn.generator.yieldT, `${fn.name} yield`, "capture");
+            add(fn.generator.nextT, `${fn.name} next`, "capture");
+            add(fn.generator.resultType, `${fn.name} generator result`, "capture");
+        }
+        for (const stmt of fn.body)
+            exprSlots(stmt, `${fn.name}`, add);
+    }
+    for (const def of mod.classes ?? []) {
+        for (const field of def.fields)
+            add(field.type, `${def.name} field ${field.name}`, "classField", def.name);
+        for (const capture of def.localCaptures ?? [])
+            add(capture.type, `${def.name} capture ${capture.name}`, "capture");
+        if (def.arrayElem !== undefined)
+            add(def.arrayElem, `${def.name} element`, "capture");
+    }
+    for (const record of mod.records ?? [])
+        for (const field of record.fields)
+            add(field.type, `record ${record.id} field ${field.name}`, "recordField");
+    for (const global of mod.globals ?? [])
+        add(global.type, `global ${global.name}`, "global");
+    for (const union of mod.unions ?? [])
+        for (const arm of union.arms)
+            add(arm, `union ${union.id}`, "expr");
+    return slots;
+}
+/** Expression types inside a statement, which must stay in the in-flight
+ * forms (the class itself or `C | null`). */
+function exprSlots(stmt, where, add) {
+    const expr = (e) => {
+        add(e.type, `${where} expression ${e.kind}`, "expr");
+        return everyExprChild(e, expr, stmtVisitor);
+    };
+    const stmtVisitor = (s) => everyStmtChild(s, expr, stmtVisitor);
+    return everyStmtChild(stmt, expr, stmtVisitor);
+}
+//# sourceMappingURL=tree-classes.js.map