@scriptc/compiler 0.4.3 → 0.4.4

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

@@ -1,7 +1,8 @@
-import { BOOL, F64, KEY_ORDER_FIELD, shapeHasAccessorSlots, typeEquals, UNDEFINED_T, } from "../../ir/ir.js";
+import { BOOL, F64, KEY_ORDER_FIELD, shapeHasAccessorSlots, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { everyExprChild, everyStmtChild, everyTypeChild, transformStmtList, } from "../../ir/traverse.js";
 import * as ts from "../ts7/adapter.js";
 import { ALWAYS_THROW_LIB_FNS } from "../../ir/builtin-effects.js";
+import { recordMayKeepSource } from "./record-sources.js";
 /** The statements a key-order helper runs for record `ref`: `walks[0]`,
  * its walk over the shape's table, or, for a shape with orderVariants, a
  * branch per order (walks[i] for order i) on the value's KEY_ORDER_FIELD.
@@ -138,6 +139,14 @@ function replacesWithoutRecords(lowerer, site) {
     return (signatures.length > 0 &&
         signatures.every((signature) => primitiveOnly(lowerer.checker.getReturnTypeOfSignature(signature))));
 }
+/** A compiler helper that boxes a class's own state for JavaScript's reads:
+ * its prototype data and the property and method dispatch over boxed
+ * instances. */
+function boxesOwnState(fnName) {
+    return (fnName.startsWith("%prototype.data.") ||
+        fnName.startsWith("%dyn.class.") ||
+        fnName.startsWith("%class."));
+}
 /** A type whose values are primitives (or void): it holds no record. */
 function primitiveOnly(type) {
     if (type.isUnionType())
@@ -198,8 +207,11 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
      * its checked field setters, each a witness of its own. A checked
      * function's parameters receive native values: a record parameter is
      * passed out, never built, though a callback among them receives values
-     * built from JavaScript again. */
-    const shapesIn = (type, out, seen, produced = false) => {
+     * built from JavaScript again. `built` false starts the walk at a value
+     * passed out (a native value boxed for JavaScript); `writes` false leaves
+     * out what JavaScript could write into the containers passed out, so the
+     * walk counts only what the functions among them receive. */
+    const shapesIn = (type, out, seen, produced = false, built = true, writes = true) => {
         const visit = (t, built) => {
             const mark = built ? "" : "-";
             // A container JavaScript builds converts into fresh native storage, so
@@ -208,7 +220,8 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
             // such as callbacks whose parameters it then builds (children passed
             // out). Those children count in both directions.
             const child = (type) => {
-                visit(type, true);
+                if (built || writes)
+                    visit(type, true);
                 if (!built)
                     visit(type, false);
                 return true;
@@ -253,7 +266,7 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
             }
             return everyTypeChild(t, child);
         };
-        visit(type, true);
+        visit(type, built);
     };
     const opaqueShapes = new Set();
     const opaqueSeen = new Set();
@@ -264,6 +277,7 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
      * declaration's order, the order their table holds. */
     const declaredShapes = new Set();
     const declaredSeen = new Set();
+    const boxedSeen = new Set();
     /** The checked result of a replaceable method call while every site that
      * can replace the method installs functions that return no record. */
     const unchangedMethodResult = (node) => {
@@ -282,6 +296,12 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
     // ── collection ──────────────────────────────────────────────────────
     let pos = 0;
     let fnName = "";
+    let currentFn = null;
+    /** Literals that start by spreading a binding, by their witness: where
+     * each one is built. A literal's notes are shared by its rebuilt copies,
+     * so `literalSites` counts every literal of each witness. */
+    const leadingSpreads = new Map();
+    const literalSites = new Map();
     const loops = [];
     let loopIds = 0;
     const loopKey = () => loops.join("/");
@@ -339,8 +359,10 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
                 }
                 const segments = notes.literalOf(e);
                 const copy = notes.copyOf(e);
-                if (segments !== undefined)
+                if (segments !== undefined) {
                     f.literals.push(segments);
+                    literalSites.set(segments, (literalSites.get(segments) ?? 0) + 1);
+                }
                 else if (copy !== undefined)
                     f.copies.push({ source: copy, keys: presentKeys });
                 else
@@ -359,9 +381,33 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
             case "assignExpr":
                 noteInit(e.localId, e.value);
                 return;
+            case "seqExpr": {
+                // A spread literal evaluates its sources into bindings first.
+                const literal = e.result;
+                if (literal.kind !== "recordLit" || currentFn === null)
+                    return;
+                const segments = notes.literalOf(literal);
+                const first = segments?.[0];
+                if (segments === undefined || first?.kind !== "spread" || first.value === undefined)
+                    return;
+                const list = leadingSpreads.get(segments) ?? [];
+                list.push({ wrapper: e, literal, fn: currentFn });
+                leadingSpreads.set(segments, list);
+                return;
+            }
             case "jsonStringify":
             case "dynFrom":
                 observedRoots.push(e.value.type);
+                // A native value the program hands to JavaScript: the callbacks it
+                // holds (itself, a field, an element) receive records JavaScript
+                // builds. The helpers that box the program's own state for
+                // JavaScript's reads (a class's prototype slots and property
+                // dispatch) hand out the class's methods, whose arguments the
+                // program's own calls pass as native values, as a replaceable
+                // method's result above. Writes through the boxed value are left
+                // out: reading a boxed value creates no record.
+                if (!boxesOwnState(fnName))
+                    shapesIn(e.value.type, runtimeShapes, boxedSeen, true, false, false);
                 return;
             case "recordKeyGet":
                 observedRoots.push(e.obj.type);
@@ -470,6 +516,7 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
     };
     for (const fn of fns) {
         fnName = fn.name;
+        currentFn = fn;
         for (const st of fn.body)
             stmt(st);
     }
@@ -598,13 +645,63 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         }
         return edges;
     };
+    // ── ordered spreads ─────────────────────────────────────────────────
+    // A value a checked conversion builds keeps its source's key order in
+    // its record source when that order is not the table's (record-
+    // sources.ts), so every value of a shape enumerates in the table's order
+    // or in the order its record source holds. A literal that starts with
+    // `...value` creates the value's keys first, in the value's order. When
+    // the value's shape is one checked conversions build, the literal
+    // carries that order over: after it builds the record it gives the
+    // record a source holding the value's order (record.sourceSpread), and
+    // the keys the value lacks follow in the table's order, which every
+    // literal sequence of the shape agrees with. Such a literal resolves as
+    // if its source were in the source's table order, and its own shape
+    // counts as built at run time too, since its values may now carry a
+    // source. It qualifies when every value of the source has all of the
+    // source's keys, both shapes can keep a source, and every later spread
+    // whose values may carry a source only overwrites the source's keys
+    // (its own order cannot move them).
+    const orderedSpreads = new Set();
+    const keepsSource = (shapeId) => recordMayKeepSource(lowerer, { kind: "record", shapeId });
+    const userKeys = (shapeId) => (shapes.get(shapeId)?.fields ?? []).map((x) => x.name).filter((k) => !k.startsWith("%"));
+    const ordersSpread = (segments, sites) => {
+        const first = segments[0];
+        if (first?.kind !== "spread" || first.maybeAbsent || first.value === undefined)
+            return false;
+        const sourceId = first.shapeId;
+        if (facts.get(sourceId)?.runtime !== true || sites.length !== literalSites.get(segments))
+            return false;
+        const target = sites[0].literal.type;
+        if (target.kind !== "record" || !keepsSource(sourceId) || !keepsSource(target.shapeId))
+            return false;
+        const localId = first.value.localId;
+        const bound = ({ wrapper, literal }) => typeEquals(literal.type, target) &&
+            wrapper.stmts.some((st) => st.kind === "varDecl" &&
+                st.localId === localId &&
+                st.init !== null &&
+                st.init.type.kind === "record" &&
+                st.init.type.shapeId === sourceId);
+        if (!sites.every(bound))
+            return false;
+        const sourceKeys = new Set(userKeys(sourceId));
+        if ([...sourceKeys].some((k) => maybeAbsent(sourceId, k)))
+            return false;
+        return segments
+            .slice(1)
+            .every((s) => s.kind === "key" ||
+            (s.kind === "spread" &&
+                (facts.get(s.shapeId)?.runtime !== true ||
+                    userKeys(s.shapeId).every((k) => sourceKeys.has(k)))));
+    };
     // ── 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 literalSequences = (segments, keySet, resolved, raw) => {
         const occurrences = [];
+        const ordered = orderedSpreads.has(segments);
         for (const s of segments) {
             if (s.kind === "opaque")
                 return null;
@@ -613,7 +710,9 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
                     occurrences.push({ key: s.name, definite: s.definite });
                 continue;
             }
-            const source = resolved(s.shapeId);
+            // An ordered spread's values without a source enumerate in the
+            // source's table; the others carry their order over.
+            const source = ordered && s === segments[0] ? raw(s.shapeId) : resolved(s.shapeId);
             if (source === "unknown")
                 return null;
             for (const k of source.order) {
@@ -709,12 +808,12 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
             first.kind === "spread" &&
             first.shapeId === id &&
             !first.maybeAbsent &&
-            !f.runtime &&
+            (!f.runtime || orderedSpreads.has(segments)) &&
             segments.every((s) => s.kind !== "opaque") &&
             table.every((k) => !maybeAbsent(id, k)));
     };
     /** One shape's order given its sources' current orders. */
-    const resolveOne = (id, current) => {
+    const resolveOne = (id, current, raw) => {
         const shape = shapes.get(id);
         if (!inScope(shape))
             return "unknown";
@@ -735,7 +834,7 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         for (const segments of f.literals) {
             if (copiesItself(id, f, table, segments))
                 continue;
-            const sequences = literalSequences(segments, keySet, current);
+            const sequences = literalSequences(segments, keySet, current, raw);
             if (sequences === null)
                 return "unknown";
             for (const seq of sequences)
@@ -799,31 +898,59 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         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;
+    const resolveAll = () => {
+        result.clear();
+        late.clear();
+        for (const scc of sccs) {
+            const members = new Set(scc);
+            const guess = new Map();
             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);
+                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);
+            const rawLookup = (id) => members.has(id) ? guess.get(id) : (result.get(id) ?? "unknown");
+            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, rawLookup);
+                    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");
         }
-        for (const id of scc)
-            result.set(id, stable ? guess.get(id) : "unknown");
+    };
+    // Ordered spreads join once their source resolves; each one can let its
+    // own shape resolve, which a later spread of it needs.
+    resolveAll();
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const [segments, sites] of leadingSpreads) {
+            const first = segments[0];
+            if (first?.kind !== "spread" || orderedSpreads.has(segments))
+                continue;
+            // A self copy resolves with its own shape.
+            const target = sites[0].literal.type;
+            const source = result.get(first.shapeId) ?? "unknown";
+            const self = target.kind === "record" && target.shapeId === first.shapeId;
+            if ((source === "unknown" && !self) || !ordersSpread(segments, sites))
+                continue;
+            orderedSpreads.add(segments);
+            if (target.kind === "record")
+                factsOf(target.shapeId).runtime = true;
+            grew = true;
+        }
+        if (grew)
+            resolveAll();
     }
     // ── observation ─────────────────────────────────────────────────────
     const observed = new Set();
@@ -832,6 +959,19 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         shapesIn({ kind: "record", shapeId: id }, observed, observedSeen);
     for (const root of observedRoots)
         shapesIn(root, observed, observedSeen);
+    // An ordered spread's copies of values without a source take the source's
+    // order from its table, which must then hold the resolved order.
+    const orderedTarget = (sites) => {
+        const target = sites[0].literal.type;
+        return target.kind === "record" && (result.get(target.shapeId) ?? "unknown") !== "unknown"
+            ? target.shapeId
+            : null;
+    };
+    for (const [segments, sites] of leadingSpreads) {
+        const first = segments[0];
+        if (orderedSpreads.has(segments) && first?.kind === "spread" && orderedTarget(sites) !== null)
+            observed.add(first.shapeId);
+    }
     // ── apply ───────────────────────────────────────────────────────────
     for (const [id, resolved] of result) {
         if (resolved === "unknown" || !observed.has(id))
@@ -845,6 +985,44 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         shape.declaredOrder = [...shape.declaredOrder.filter(isArrayIndex), ...resolved.order];
         notes.changed.add(id);
     }
+    // Ordered spreads carry their source's order over (see above).
+    let orderedResults = 0;
+    const rewritten = new Set();
+    for (const [segments, sites] of leadingSpreads) {
+        const first = segments[0];
+        if (!orderedSpreads.has(segments) || first?.kind !== "spread" || first.value === undefined)
+            continue;
+        // A shape that did not resolve keeps today's table for every value.
+        if (orderedTarget(sites) === null)
+            continue;
+        for (const { wrapper, literal, fn } of sites) {
+            if (rewritten.has(wrapper))
+                continue;
+            rewritten.add(wrapper);
+            const loc = literal.loc;
+            const localId = `%orderedSpread.${orderedResults++}`;
+            fn.locals.push({ id: localId, name: "%orderedSpread", type: literal.type, mutable: false });
+            const built = { kind: "varRef", localId, type: literal.type, loc };
+            const source = {
+                kind: "varRef",
+                localId: first.value.localId,
+                type: { kind: "record", shapeId: first.shapeId },
+                loc,
+            };
+            wrapper.stmts.push({ kind: "varDecl", localId, init: literal, loc }, {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "record.sourceSpread",
+                    args: [built, source],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            });
+            wrapper.result = { kind: "varRef", localId, type: literal.type, loc };
+        }
+    }
     // ── per-instance orders ─────────────────────────────────────────────
     // A shape whose literals write its keys in more than one order has no
     // one table. Each value then records which of the orders it was written