@scriptc/compiler 0.3.5 → 0.4.0

package/dist/frontend/lowering/key-order-witness.js

@@ -0,0 +1,641 @@
+import { shapeHasAccessorSlots, typeEquals, UNDEFINED_T } from "../../ir/ir.js";
+import { everyExprChild, everyStmtChild, everyTypeChild } from "../../ir/traverse.js";
+/** Witness notes the lowering attaches to the IR nodes it builds. Keyed by
+ * node identity, so nodes a speculative lowering discards are never walked,
+ * and a node some later pass rebuilds falls back to pinning. */
+export class KeyOrderNotes {
+    literals = new Map();
+    copies = new Map();
+    /** Shapes a frontend order surface (keys, values/entries, inspect,
+     * index-signature merges) walks. */
+    observed = new Set();
+    /** Shapes whose table this pass replaced. */
+    changed = new Set();
+    literal(node, segments) {
+        this.literals.set(node, segments);
+        return node;
+    }
+    copy(node, sourceShapeId) {
+        this.copies.set(node, sourceShapeId);
+        return node;
+    }
+    observe(type) {
+        if (type.kind === "record")
+            this.observed.add(type.shapeId);
+    }
+    literalOf(node) {
+        return this.literals.get(node);
+    }
+    copyOf(node) {
+        return this.copies.get(node);
+    }
+}
+const isArrayIndex = (name) => {
+    const n = Number(name);
+    return Number.isInteger(n) && n >= 0 && n < 4294967295 && String(n) === name;
+};
+/** `structuredClone(v)` checked back into v's own type: the copy is built
+ * from v's dyn view, so it creates exactly v's keys in v's order. */
+function orderPreservingClone(node) {
+    const value = node.value;
+    if (value.kind !== "libCall" || value.fn !== "dyn.structuredClone")
+        return false;
+    const source = value.args[0];
+    return (source !== undefined && source.kind === "dynFrom" && typeEquals(source.value.type, node.type));
+}
+/** Chooses each in-scope record shape's enumeration table from its
+ * witnesses. Runs once retained reachability has settled the historical
+ * tables and derived metadata, before the order-snapshotting helper bodies
+ * rebuild. */
+export function applyKeyOrderWitnesses(lowerer, fns) {
+    const notes = lowerer.keyOrder;
+    const shapes = lowerer.shapes;
+    const facts = new Map();
+    const factsOf = (shapeId) => {
+        let f = facts.get(shapeId);
+        if (f === undefined) {
+            f = {
+                literals: [],
+                copies: [],
+                pinned: false,
+                opaque: false,
+                runtime: false,
+                clones: false,
+                present: new Set(),
+                absent: new Set(),
+                deleted: new Set(),
+                writes: [],
+            };
+            facts.set(shapeId, f);
+        }
+        return f;
+    };
+    const observedRoots = [];
+    const inits = new Map();
+    const undefinedArmed = (t) => t.kind === "union" && lowerer.armTag(t.unionId, UNDEFINED_T) >= 0;
+    const containsAbsent = (value) => value.kind === "fieldAbsent" ||
+        (value.kind === "ternary" && (containsAbsent(value.then) || containsAbsent(value.else_)));
+    /** Every record shape a type can hold, through fields, arms, elements,
+     * callables, promises and class fields. */
+    /** Each walk shares one `seen` set per result set, so every type graph
+     * is walked once however many roots reach it. */
+    const shapesIn = (type, out, seen) => {
+        const visit = (t) => {
+            if (t.kind === "record") {
+                if (seen.has("r:" + t.shapeId))
+                    return true;
+                seen.add("r:" + t.shapeId);
+                out.add(t.shapeId);
+                const shape = shapes.get(t.shapeId);
+                if (shape) {
+                    for (const f of shape.fields)
+                        visit(f.type);
+                    if (shape.indexValue)
+                        visit(shape.indexValue);
+                }
+                return true;
+            }
+            if (t.kind === "union") {
+                if (seen.has("u:" + t.unionId))
+                    return true;
+                seen.add("u:" + t.unionId);
+                for (const arm of lowerer.unions.get(t.unionId)?.arms ?? [])
+                    visit(arm);
+                return true;
+            }
+            if (t.kind === "object") {
+                if (seen.has("c:" + t.className))
+                    return true;
+                seen.add("c:" + t.className);
+                for (const f of lowerer.classes.get(t.className)?.def.fields ?? [])
+                    visit(f.type);
+                return true;
+            }
+            return everyTypeChild(t, visit);
+        };
+        visit(type);
+    };
+    const opaqueShapes = new Set();
+    const opaqueSeen = new Set();
+    const runtimeShapes = new Set();
+    const runtimeSeen = new Set();
+    const producedBy = (type, opaque) => {
+        if (opaque)
+            shapesIn(type, opaqueShapes, opaqueSeen);
+        else
+            shapesIn(type, runtimeShapes, runtimeSeen);
+    };
+    // ── collection ──────────────────────────────────────────────────────
+    let pos = 0;
+    let fnName = "";
+    const loops = [];
+    let loopIds = 0;
+    const loopKey = () => loops.join("/");
+    /** Bindings initialized by another binding's reference (`const view =
+     * value`, the snapshot a union-receiver write takes), so writes through
+     * either count as writes through the one object. */
+    const aliases = new Map();
+    const bindingOf = (obj) => {
+        let o = obj;
+        while (o.kind === "unionNarrow" || o.kind === "downcast")
+            o = o.value;
+        if (o.kind !== "varRef")
+            return null;
+        let id = o.localId;
+        const seen = new Set();
+        for (;;) {
+            const alias = aliases.get(id);
+            if (!alias || alias.fn !== fnName || inits.get(id)?.count !== 1 || seen.has(id))
+                return id;
+            seen.add(id);
+            id = alias.target;
+        }
+    };
+    const noteInit = (id, init) => {
+        const previous = inits.get(id);
+        if (previous !== undefined) {
+            previous.count++;
+            return;
+        }
+        if (init.kind === "varRef")
+            aliases.set(id, { target: init.localId, fn: fnName });
+        const fresh = init.kind === "recordLit" ||
+            init.kind === "recordClone" ||
+            (init.kind === "seqExpr" && init.result.kind === "recordLit");
+        inits.set(id, { count: 1, fn: fnName, loop: loopKey(), pos, fresh });
+    };
+    const visitExpr = (e) => {
+        switch (e.kind) {
+            case "recordLit": {
+                if (e.type.kind !== "record")
+                    return;
+                const f = factsOf(e.type.shapeId);
+                const presentKeys = new Set();
+                for (const field of e.fields) {
+                    if (field.overflow)
+                        continue;
+                    if (field.value.kind === "fieldAbsent") {
+                        f.absent.add(field.name);
+                        continue;
+                    }
+                    presentKeys.add(field.name);
+                    f.present.add(field.name);
+                    if (containsAbsent(field.value))
+                        f.absent.add(field.name);
+                }
+                const segments = notes.literalOf(e);
+                const copy = notes.copyOf(e);
+                if (segments !== undefined)
+                    f.literals.push(segments);
+                else if (copy !== undefined)
+                    f.copies.push({ source: copy, keys: presentKeys });
+                else
+                    f.pinned = true;
+                return;
+            }
+            case "recordClone": {
+                if (e.type.kind !== "record")
+                    return;
+                const f = factsOf(e.type.shapeId);
+                f.clones = true;
+                for (const o of e.overrides)
+                    f.writes.push({ field: o.name, kind: "clone", fn: fnName, binding: null, loop: "", pos });
+                return;
+            }
+            case "assignExpr":
+                noteInit(e.localId, e.value);
+                return;
+            case "jsonStringify":
+            case "dynFrom":
+                observedRoots.push(e.value.type);
+                return;
+            case "recordKeyGet":
+                observedRoots.push(e.obj.type);
+                return;
+            case "libCall":
+                // Runtime surfaces (console, util.format, workers) that take a
+                // record may walk its keys; runtime builders make new records.
+                for (const arg of e.args)
+                    observedRoots.push(arg.type);
+                producedBy(e.type, true);
+                return;
+            case "intrinsic":
+                // Intrinsics hand back values built elsewhere, except allSettled's
+                // result records; console output renders through the inspect
+                // helpers, which note their shapes.
+                if (e.name === "promise.allSettled")
+                    producedBy(e.type, true);
+                return;
+            case "ffiCall":
+            case "strIntrinsic":
+            case "regexIntrinsic":
+            case "bytesIntrinsic":
+                producedBy(e.type, true);
+                return;
+            case "dynCheck":
+                if (!orderPreservingClone(e))
+                    producedBy(e.type, false);
+                return;
+            case "dynDestrCheck":
+            case "caughtCheck":
+            case "caughtNarrow":
+                producedBy(e.type, false);
+                return;
+            default:
+                return;
+        }
+    };
+    const visitStmt = (st) => {
+        switch (st.kind) {
+            case "recordSet":
+                if (st.value.kind === "fieldAbsent")
+                    factsOf(st.shapeId).deleted.add(st.field);
+                factsOf(st.shapeId).writes.push({
+                    field: st.field,
+                    kind: st.value.kind === "fieldAbsent" ? "delete" : "write",
+                    fn: fnName,
+                    binding: bindingOf(st.obj),
+                    loop: loopKey(),
+                    pos,
+                });
+                return;
+            case "varDecl":
+                if (st.init !== null)
+                    noteInit(st.localId, st.init);
+                return;
+            case "assign":
+                noteInit(st.localId, st.value);
+                return;
+            default:
+                return;
+        }
+    };
+    const expr = (e) => {
+        pos++;
+        visitExpr(e);
+        return everyExprChild(e, expr, stmt);
+    };
+    const stmt = (st) => {
+        pos++;
+        visitStmt(st);
+        if (st.kind === "while" || st.kind === "doWhile" || st.kind === "for" || st.kind === "forOf") {
+            loops.push(++loopIds);
+            everyStmtChild(st, expr, stmt);
+            loops.pop();
+            return true;
+        }
+        return everyStmtChild(st, expr, stmt);
+    };
+    for (const fn of fns) {
+        fnName = fn.name;
+        for (const st of fn.body)
+            stmt(st);
+    }
+    for (const id of opaqueShapes) {
+        const f = factsOf(id);
+        f.pinned = true;
+        f.opaque = true;
+    }
+    for (const id of runtimeShapes)
+        factsOf(id).runtime = true;
+    // ── scope ───────────────────────────────────────────────────────────
+    // Only plain declared-field shapes with a table take part.
+    const inScope = (shape) => shape !== undefined &&
+        !shape.tuple &&
+        shape.indexValue === undefined &&
+        shape.declaredOrder !== undefined &&
+        !shapeHasAccessorSlots(shape);
+    const tableOf = (shape) => shape.declaredOrder.filter((k) => !k.startsWith("%") && !isArrayIndex(k));
+    // A checked conversion builds values in their source's own order, which
+    // the record-source table reproduces relative to the shape's table. A new
+    // table would make every value parsed in today's order keep a source
+    // view, so such shapes keep today's table.
+    for (const f of facts.values())
+        if (f.runtime)
+            f.pinned = true;
+    // Nothing to choose: every witness agrees with today's table and no
+    // optional key is written late.
+    const interesting = [...facts].some(([id, f]) => {
+        const shape = shapes.get(id);
+        if (!inScope(shape))
+            return false;
+        if (f.writes.some((w) => w.kind !== "delete") || f.copies.length > 0)
+            return true;
+        const table = tableOf(shape).join("\0");
+        return f.literals.some((segments) => {
+            const keys = [];
+            for (const segment of segments) {
+                if (segment.kind !== "key")
+                    return true;
+                if (!isArrayIndex(segment.name))
+                    keys.push(segment.name);
+            }
+            return keys.join("\0") !== table;
+        });
+    });
+    if (!interesting)
+        return;
+    // ── presence classes and late-write constraints ─────────────────────
+    const maybeAbsent = (id, key) => {
+        const shape = shapes.get(id);
+        const field = shape?.fields.find((x) => x.name === key);
+        if (!field || !undefinedArmed(field.type))
+            return false;
+        const f = facts.get(id);
+        if (f === undefined)
+            return true;
+        return f.absent.has(key) || f.runtime || f.opaque || f.deleted.has(key);
+    };
+    /** Edges every value of the shape satisfies whatever its sources'
+     * orders are, or "unknown" when late writes make the order depend on
+     * the value. */
+    const lateEdges = (id, keys) => {
+        const f = facts.get(id);
+        if (f === undefined)
+            return [];
+        const edges = [];
+        const keySet = new Set(keys);
+        const createdKeys = (k) => f.present.has(k) || f.runtime || f.opaque;
+        const required = keys.filter((k) => !maybeAbsent(id, k));
+        const created = keys.filter((k) => maybeAbsent(id, k) && createdKeys(k));
+        const lateOnly = new Set(keys.filter((k) => maybeAbsent(id, k) && !createdKeys(k)));
+        // The constraint depends on the written key only, not on the site.
+        const moving = new Set();
+        for (const w of f.writes)
+            if (w.kind !== "delete" && keySet.has(w.field) && maybeAbsent(id, w.field))
+                moving.add(w.field);
+        for (const field of moving) {
+            const before = lateOnly.has(field) ? [...required, ...created] : keys;
+            for (const k of before)
+                if (k !== field)
+                    edges.push([k, field]);
+        }
+        const lateSites = f.writes.filter((w) => lateOnly.has(w.field));
+        const lateWritten = new Set(lateSites.filter((w) => w.kind !== "delete").map((w) => w.field));
+        if (lateWritten.size < 2)
+            return edges;
+        // Two or more late-only keys: each value gains them in the order its
+        // writes run, so every write must belong to one straight-line
+        // sequence through one binding initialized once, in the same function
+        // and loop body as its writes.
+        const groups = new Map();
+        for (const w of lateSites) {
+            if (w.kind === "clone" || w.binding === null)
+                return "unknown";
+            const init = inits.get(w.binding);
+            if (init === undefined ||
+                init.count !== 1 ||
+                init.fn !== w.fn ||
+                init.loop !== w.loop ||
+                init.pos > w.pos)
+                return "unknown";
+            const group = groups.get(w.binding) ?? [];
+            group.push(w);
+            groups.set(w.binding, group);
+        }
+        if (groups.size > 1 && [...groups.keys()].some((b) => !inits.get(b).fresh))
+            return "unknown";
+        for (const group of groups.values()) {
+            const seen = new Set();
+            for (const w of group) {
+                if (seen.has(w.field))
+                    return "unknown";
+                seen.add(w.field);
+            }
+            const writes = group.filter((w) => w.kind === "write").sort((a, b) => a.pos - b.pos);
+            for (let i = 0; i + 1 < writes.length; i++)
+                edges.push([writes[i].field, writes[i + 1].field]);
+        }
+        return edges;
+    };
+    // ── witness sequences ───────────────────────────────────────────────
+    /** The key sequences one literal can create, or null when a spread
+     * source's order is unknown. A key sits at its first occurrence that
+     * certainly defines it; each earlier occurrence that may define it is
+     * another possible position. */
+    const literalSequences = (segments, keySet, resolved) => {
+        const occurrences = [];
+        for (const s of segments) {
+            if (s.kind === "opaque")
+                return null;
+            if (s.kind === "key") {
+                if (keySet.has(s.name))
+                    occurrences.push({ key: s.name, definite: s.definite });
+                continue;
+            }
+            const source = resolved(s.shapeId);
+            if (source === "unknown")
+                return null;
+            for (const k of source.order) {
+                if (keySet.has(k))
+                    occurrences.push({ key: k, definite: !s.maybeAbsent && !maybeAbsent(s.shapeId, k) });
+            }
+        }
+        // Per key, the occurrences that can create it: every one up to and
+        // including the first definite occurrence. The first such position is
+        // the base; each other one is an alternative.
+        const positions = new Map();
+        const settled = new Set();
+        occurrences.forEach((o, i) => {
+            if (settled.has(o.key))
+                return;
+            const list = positions.get(o.key) ?? [];
+            list.push(i);
+            positions.set(o.key, list);
+            if (o.definite)
+                settled.add(o.key);
+        });
+        const base = new Map();
+        for (const [key, list] of positions)
+            base.set(key, list[0]);
+        const sequenceWith = (at) => [...at].sort((a, b) => a[1] - b[1]).map(([k]) => k);
+        const out = [sequenceWith(base)];
+        for (const [key, list] of positions) {
+            for (const alternative of list.slice(1)) {
+                const moved = new Map(base);
+                moved.set(key, alternative);
+                out.push(sequenceWith(moved));
+            }
+        }
+        return out;
+    };
+    /** Today's table with every witness edge applied, or "unknown". */
+    const merge = (table, edges) => {
+        const rank = new Map(table.map((k, i) => [k, i]));
+        const succ = new Map(table.map((k) => [k, new Set()]));
+        const indeg = new Map(table.map((k) => [k, 0]));
+        for (const [a, b] of edges) {
+            if (a === b || !rank.has(a) || !rank.has(b))
+                continue;
+            const s = succ.get(a);
+            if (s.has(b))
+                continue;
+            s.add(b);
+            indeg.set(b, indeg.get(b) + 1);
+        }
+        const order = [];
+        const ready = table.filter((k) => indeg.get(k) === 0);
+        while (ready.length > 0) {
+            ready.sort((a, b) => rank.get(a) - rank.get(b));
+            const k = ready.shift();
+            order.push(k);
+            for (const next of succ.get(k)) {
+                indeg.set(next, indeg.get(next) - 1);
+                if (indeg.get(next) === 0)
+                    ready.push(next);
+            }
+        }
+        return order.length === table.length ? { order } : "unknown";
+    };
+    const chain = (seq, out) => {
+        for (let i = 0; i + 1 < seq.length; i++)
+            out.push([seq[i], seq[i + 1]]);
+    };
+    // ── resolution over inheritance edges ───────────────────────────────
+    const result = new Map();
+    const late = new Map();
+    const dependencies = (id) => {
+        const f = facts.get(id);
+        if (f === undefined)
+            return [];
+        const deps = new Set();
+        for (const segments of f.literals)
+            for (const s of segments)
+                if (s.kind === "spread")
+                    deps.add(s.shapeId);
+        for (const c of f.copies)
+            deps.add(c.source);
+        return [...deps];
+    };
+    /** One shape's order given its sources' current orders. */
+    const resolveOne = (id, current) => {
+        const shape = shapes.get(id);
+        if (!inScope(shape))
+            return "unknown";
+        const table = tableOf(shape);
+        const f = facts.get(id);
+        // A shape the program never constructs natively gets its values from
+        // somewhere this pass cannot see.
+        if (f === undefined || !(f.literals.length > 0 || f.copies.length > 0 || f.pinned || f.runtime))
+            return "unknown";
+        // Clones copy their source's own key order, which a checked
+        // conversion leaves unknown.
+        if (f.runtime && f.clones)
+            return "unknown";
+        const keySet = new Set(table);
+        const edges = [];
+        if (f.pinned)
+            chain(table, edges);
+        for (const segments of f.literals) {
+            const sequences = literalSequences(segments, keySet, current);
+            if (sequences === null)
+                return "unknown";
+            for (const seq of sequences)
+                chain(seq, edges);
+        }
+        for (const c of f.copies) {
+            const source = current(c.source);
+            if (source === "unknown")
+                return "unknown";
+            chain(source.order.filter((k) => keySet.has(k) && c.keys.has(k)), edges);
+        }
+        const cached = late.get(id);
+        const lateFor = cached !== undefined ? cached : lateEdges(id, table);
+        if (cached === undefined)
+            late.set(id, lateFor);
+        if (lateFor === "unknown")
+            return "unknown";
+        for (const edge of lateFor)
+            edges.push(edge);
+        return merge(table, edges);
+    };
+    /** A source's order as its copies see it: values of a shape built by a
+     * checked conversion keep their source's own order. */
+    const asSource = (id, resolved) => facts.get(id)?.runtime === true ? "unknown" : resolved;
+    // Tarjan's SCCs over "depends on" edges: sources finish first.
+    const index = new Map();
+    const low = new Map();
+    const stack = [];
+    const onStack = new Set();
+    let counter = 0;
+    const sccs = [];
+    const strong = (v) => {
+        index.set(v, counter);
+        low.set(v, counter);
+        counter++;
+        stack.push(v);
+        onStack.add(v);
+        for (const w of dependencies(v)) {
+            if (!index.has(w)) {
+                strong(w);
+                low.set(v, Math.min(low.get(v), low.get(w)));
+            }
+            else if (onStack.has(w))
+                low.set(v, Math.min(low.get(v), index.get(w)));
+        }
+        if (low.get(v) === index.get(v)) {
+            const scc = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                scc.push(w);
+            } while (w !== v);
+            sccs.push(scc);
+        }
+    };
+    for (const id of facts.keys())
+        if (!index.has(id))
+            strong(id);
+    const external = (id) => {
+        const known = result.get(id);
+        return known === undefined ? "unknown" : asSource(id, known);
+    };
+    for (const scc of sccs) {
+        const members = new Set(scc);
+        const guess = new Map();
+        for (const id of scc) {
+            const shape = shapes.get(id);
+            guess.set(id, inScope(shape) ? { order: tableOf(shape) } : "unknown");
+        }
+        const lookup = (id) => members.has(id) ? asSource(id, guess.get(id)) : external(id);
+        let stable = false;
+        for (let round = 0; round < scc.length + 3 && !stable; round++) {
+            stable = true;
+            for (const id of scc) {
+                const next = resolveOne(id, lookup);
+                const prev = guess.get(id);
+                const same = next === "unknown"
+                    ? prev === "unknown"
+                    : prev !== "unknown" && prev.order.join("\0") === next.order.join("\0");
+                if (!same) {
+                    stable = false;
+                    guess.set(id, next);
+                }
+            }
+        }
+        for (const id of scc)
+            result.set(id, stable ? guess.get(id) : "unknown");
+    }
+    // ── observation ─────────────────────────────────────────────────────
+    const observed = new Set();
+    const observedSeen = new Set();
+    for (const id of notes.observed)
+        shapesIn({ kind: "record", shapeId: id }, observed, observedSeen);
+    for (const root of observedRoots)
+        shapesIn(root, observed, observedSeen);
+    // ── apply ───────────────────────────────────────────────────────────
+    for (const [id, resolved] of result) {
+        if (resolved === "unknown" || !observed.has(id))
+            continue;
+        const shape = shapes.get(id);
+        if (!inScope(shape))
+            continue;
+        const table = tableOf(shape);
+        if (resolved.order.join("\0") === table.join("\0"))
+            continue;
+        shape.declaredOrder = [...shape.declaredOrder.filter(isArrayIndex), ...resolved.order];
+        notes.changed.add(id);
+    }
+}
+//# sourceMappingURL=key-order-witness.js.map