@scriptc/compiler 0.4.6 → 0.4.7

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

@@ -1,8 +1,11 @@
-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 { dynUndefinedExpr, strLit } from "../../ir/build.js";
+import { BOOL, DYN, F64, KEY_ORDER_FIELD, shapeHasAccessorSlots, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
+import { everyExprChild, everyStmtChild, everyStmtList, 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";
+import { replaceChildExpr } from "../../ir/fields.generated.js";
+import { InternalCompilerError } from "../../errors.js";
+import { recordMayKeepSource, recordSourceTest } 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.
@@ -39,25 +42,77 @@ export class KeyOrderNotes {
     literals = new Map();
     copies = new Map();
     methodResults = new Map();
+    /** Literals whose spreads copy source keys the target does not declare
+     * (a width spread), with their contributors (keepWidthSpreads), and
+     * every spread literal over a shape that can keep a source (same-shape
+     * copies, which keep the source's undeclared keys when it has any). */
+    widths = new Map();
+    /** `"k" in r` answers over a closed record whose literal key the shape
+     * does not declare, with the receiver the static form evaluated
+     * (keepSourceProbes). */
+    sourceProbes = new Map();
+    /** Same-shape `{ ...r, k: v }` clones (lowerObjectLiteral's recordClone
+     * fast path), which copy the source's own keys too (keepRecordClones). */
+    clones = new Set();
     /** 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();
+    /** Width-spread literals this pass kept as a record's source
+     * (keepWidthSpreads). A kept copy holds undeclared keys, so the
+     * index-signature capture must consult it (lowerer.ts). */
+    keptWidthSpreads = 0;
+    /** The shapes those kept copies build. A width spread or clone only
+     * keeps a source on a shape in here, so the reflective helpers
+     * (lower-calls.ts) stay static for every other shape, and the pass reads
+     * it back as a spread source that can already hold one. */
+    keptSourceShapes = new Set();
     /** The sizes of the notes' tables (unit-journal.ts). */
     journalSizes() {
         return [
             this.literals.size,
             this.copies.size,
             this.methodResults.size,
+            this.widths.size,
+            this.sourceProbes.size,
+            this.clones.size,
             this.observed.size,
             this.changed.size,
+            this.keptSourceShapes.size,
         ];
     }
     literal(node, segments) {
         this.literals.set(node, segments);
         return node;
     }
+    /** A record literal whose spreads copy source keys the target does not
+     * declare (`drops`), with its contributors. */
+    width(node, segments, drops) {
+        this.widths.set(node, { segments, drops });
+        return node;
+    }
+    widthOf(node) {
+        return this.widths.get(node);
+    }
+    /** A statically-false `"k" in r` over a closed record, which a kept
+     * source can make true. */
+    sourceProbe(node, receiver, key) {
+        this.sourceProbes.set(node, { receiver, key });
+        return node;
+    }
+    sourceProbeOf(node) {
+        return this.sourceProbes.get(node);
+    }
+    /** A same-shape `{ ...r, k: v }` clone, which copies the source's own
+     * keys as Node does. */
+    clone(node) {
+        this.clones.add(node);
+        return node;
+    }
+    isClone(node) {
+        return this.clones.has(node);
+    }
     copy(node, sourceShapeId) {
         this.copies.set(node, sourceShapeId);
         return node;
@@ -80,6 +135,14 @@ export class KeyOrderNotes {
         const method = this.methodResults.get(from);
         if (method !== undefined)
             this.methodResults.set(to, method);
+        const width = this.widths.get(from);
+        if (width !== undefined)
+            this.widths.set(to, width);
+        const probe = this.sourceProbes.get(from);
+        if (probe !== undefined)
+            this.sourceProbes.set(to, probe);
+        if (this.clones.has(from))
+            this.clones.add(to);
     }
     observe(type) {
         if (type.kind === "record")
@@ -201,6 +264,8 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         return f;
     };
     const observedRoots = [];
+    /** The receivers of the program's own-key presence tests. */
+    const presenceRoots = [];
     const inits = new Map();
     const undefinedArmed = (t) => t.kind === "union" && lowerer.armTag(t.unionId, UNDEFINED_T) >= 0;
     const containsAbsent = (value) => value.kind === "fieldAbsent" ||
@@ -311,6 +376,13 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
      * 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();
+    /** Width literals (KeyOrderNotes.width), where each is built. */
+    const widthSites = [];
+    /** `"k" in r` sites a kept source can answer true (keepSourceProbes). */
+    const probeSites = [];
+    /** Same-shape `{ ...r, k: v }` clones that copy the source's own keys
+     * (keepRecordClones). */
+    const cloneSites = [];
     const literalSites = new Map();
     const loops = [];
     let loopIds = 0;
@@ -349,6 +421,13 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         inits.set(id, { count: 1, fn: fnName, loop: loopKey(), pos, fresh });
     };
     const visitExpr = (e) => {
+        const probe = notes.sourceProbeOf(e);
+        if (probe !== undefined && currentFn !== null) {
+            probeSites.push({ node: e, fn: currentFn });
+            presenceRoots.push(probe.receiver.type);
+        }
+        if (e.kind === "call" && e.callee.startsWith("%obj.hasOwn") && e.args[0] !== undefined)
+            presenceRoots.push(e.args[0].type);
         switch (e.kind) {
             case "recordLit": {
                 if (e.type.kind !== "record")
@@ -382,6 +461,8 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
             case "recordClone": {
                 if (e.type.kind !== "record")
                     return;
+                if (notes.isClone(e) && currentFn !== null)
+                    cloneSites.push({ node: e, fn: currentFn });
                 const f = factsOf(e.type.shapeId);
                 f.clones = true;
                 for (const o of e.overrides)
@@ -396,6 +477,9 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
                 const literal = e.result;
                 if (literal.kind !== "recordLit" || currentFn === null)
                     return;
+                const width = notes.widthOf(literal);
+                if (width !== undefined)
+                    widthSites.push({ wrapper: e, literal, fn: currentFn, note: width });
                 const segments = notes.literalOf(literal);
                 const first = segments?.[0];
                 if (segments === undefined || first?.kind !== "spread" || first.value === undefined)
@@ -540,6 +624,157 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
     for (const id of declaredShapes)
         if (!runtimeShapes.has(id))
             factsOf(id).pinned = true;
+    // ── width spreads ───────────────────────────────────────────────────
+    // A width spread keeps the copy's own keys when an order surface can
+    // observe its target (keepWidthSpreads). The observation is the one the
+    // tables use below, before ordered spreads join it. A source can be
+    // another width spread's target, so this runs until no site joins.
+    const keptWidths = new Set();
+    const keptClones = new Set();
+    /** The shapes a checked conversion in this program builds, which are the
+     * only values that already hold a source when this pass runs (the ones
+     * this pass keeps join keptSourceShapes as it decides). */
+    const convertedShapes = new Set();
+    {
+        const seen = new Set();
+        for (const fn of fns)
+            everyStmtList(fn.body, {
+                expr: (expr) => {
+                    if (expr.kind === "dynCheck")
+                        conversionShapes(lowerer, expr.type, convertedShapes, seen);
+                    return true;
+                },
+                stmt: () => true,
+            });
+    }
+    /** The statements each kept site's literal evaluates in (the wrapper's
+     * prologue), which the per-instance order plan reads a spread's source
+     * binding from after keepWidthSpreads moved the literal into a
+     * declaration of its own. */
+    const keptLiteralStmts = new Map();
+    /** Shapes a kept dropping copy builds: the copy holds keys the shape has
+     * no slot for, so its order is its kept source's, and the shape keeps
+     * today's table (as a literal with a dropped field does without the
+     * kept source). */
+    const keptDropShapes = new Set();
+    {
+        const early = new Set();
+        const earlySeen = new Set();
+        for (const id of notes.observed)
+            shapesIn({ kind: "record", shapeId: id }, early, earlySeen);
+        for (const root of observedRoots)
+            shapesIn(root, early, earlySeen);
+        // A presence test (`"k" in r`, Object.hasOwn) observes a record's own
+        // keys as an order surface does.
+        for (const root of presenceRoots)
+            shapesIn(root, early, earlySeen);
+        // An observed copy shows the own keys of each record it spreads, so a
+        // spread source is observed through it, transitively.
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const { literal, note } of widthSites) {
+                if (literal.type.kind !== "record" || !early.has(literal.type.shapeId))
+                    continue;
+                for (const segment of note.segments) {
+                    if (segment.kind !== "spread")
+                        continue;
+                    const before = early.size;
+                    shapesIn(segment.value.type, early, earlySeen);
+                    if (early.size !== before)
+                        grew = true;
+                }
+            }
+        }
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const { wrapper, literal, note } of widthSites) {
+                if (!note.drops || keptWidths.has(wrapper) || literal.type.kind !== "record")
+                    continue;
+                if (!early.has(literal.type.shapeId) || !widthKeepable(lowerer, wrapper, note.segments))
+                    continue;
+                keptWidths.add(wrapper);
+                notes.keptSourceShapes.add(literal.type.shapeId);
+                grew = true;
+                for (const segment of note.segments)
+                    if (segment.kind === "spread")
+                        shapesIn(segment.value.type, early, earlySeen);
+            }
+        }
+        // A same-shape copy (`{ ...r }`, `{ ...r, ...s }`) of a record that
+        // kept undeclared keys copies them too. A copy keeps its source's own
+        // keys, so a source can itself be such a copy; admit a non-dropping
+        // site only when a spread source of it can actually hold a source (a
+        // shape a checked conversion builds or an earlier kept copy's), so a
+        // program — or a copy of a shape no conversion ever produces — stays
+        // byte-identical.
+        if (lowerer.recordSourcesPossible || keptWidths.size > 0) {
+            for (let grew = true; grew;) {
+                grew = false;
+                for (const { wrapper, literal, note } of widthSites) {
+                    if (note.drops || keptWidths.has(wrapper) || literal.type.kind !== "record")
+                        continue;
+                    if (!early.has(literal.type.shapeId) || !widthKeepable(lowerer, wrapper, note.segments))
+                        continue;
+                    if (!note.segments.some((segment) => segment.kind === "spread" &&
+                        reachesKeptSource(lowerer, segment.value.type, convertedShapes)))
+                        continue;
+                    keptWidths.add(wrapper);
+                    notes.keptSourceShapes.add(literal.type.shapeId);
+                    grew = true;
+                    for (const segment of note.segments)
+                        if (segment.kind === "spread")
+                            shapesIn(segment.value.type, early, earlySeen);
+                }
+            }
+        }
+        for (const { wrapper, literal, note } of widthSites) {
+            if (!keptWidths.has(wrapper) || literal.type.kind !== "record")
+                continue;
+            const shapeId = literal.type.shapeId;
+            notes.keptSourceShapes.add(shapeId);
+            if (!note.drops) {
+                // A same-shape copy keeps its own order (a spread of the literal's
+                // own shape reads its source's index): its witness stays, and the
+                // plan finds the source binding through the wrapper's prologue.
+                keptLiteralStmts.set(literal, wrapper.stmts);
+                continue;
+            }
+            // A kept copy that drops keys enumerates through its own kept source,
+            // so like a checked conversion it contributes no order to its shape's
+            // table, and the shape keeps today's table.
+            const segments = notes.literalOf(literal);
+            const literals = facts.get(shapeId)?.literals;
+            const at = segments === undefined || literals === undefined ? -1 : literals.indexOf(segments);
+            if (at >= 0)
+                literals.splice(at, 1);
+            keptDropShapes.add(shapeId);
+        }
+        // Same-shape clones of a record that can keep keys copy them too, when
+        // the program converts checked values or keeps a width spread and the
+        // shape is observed. The source, not the clone, decides: a clone of a
+        // shape no conversion produces finds no keys to keep.
+        if (lowerer.recordSourcesPossible || keptWidths.size > 0) {
+            for (const { node } of cloneSites) {
+                if (node.kind !== "recordClone")
+                    continue;
+                const cloneT = node.type;
+                if (cloneT.kind !== "record" || !early.has(cloneT.shapeId))
+                    continue;
+                if (!recordMayKeepSource(lowerer, cloneT))
+                    continue;
+                if (!reachesKeptSource(lowerer, node.source.type, convertedShapes))
+                    continue;
+                keptClones.add(node);
+                notes.keptSourceShapes.add(cloneT.shapeId);
+            }
+        }
+    }
+    // A program that keeps no width spread is byte-identical to main: the
+    // reflective surfaces below (and the two helper finalizers in
+    // lower-calls.ts, which consult keptSourceShapes) stay static there, as
+    // they did before this pass.
+    keepSourceProbes(lowerer, notes, probeSites, keptWidths.size > 0 || keptClones.size > 0);
+    keepRecordClones(lowerer, cloneSites, keptClones);
     // ── scope ───────────────────────────────────────────────────────────
     // Only plain declared-field shapes with a table take part.
     const inScope = (shape) => shape !== undefined &&
@@ -580,8 +815,10 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
             return keys.join("\0") !== table;
         });
     });
-    if (!interesting)
+    if (!interesting) {
+        keepWidthSpreads(notes, widthSites, keptWidths, new Set());
         return;
+    }
     // ── presence classes and late-write constraints ─────────────────────
     const maybeAbsent = (id, key) => {
         const shape = shapes.get(id);
@@ -969,6 +1206,15 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         shapesIn({ kind: "record", shapeId: id }, observed, observedSeen);
     for (const root of observedRoots)
         shapesIn(root, observed, observedSeen);
+    // A kept width spread snapshots its sources' own keys, an order surface
+    // over each source.
+    for (const { wrapper, note } of widthSites) {
+        if (!keptWidths.has(wrapper))
+            continue;
+        for (const segment of note.segments)
+            if (segment.kind === "spread")
+                shapesIn(segment.value.type, 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) => {
@@ -998,6 +1244,7 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
     // Ordered spreads carry their source's order over (see above).
     let orderedResults = 0;
     const rewritten = new Set();
+    keepWidthSpreads(notes, widthSites, keptWidths, rewritten);
     for (const [segments, sites] of leadingSpreads) {
         const first = segments[0];
         if (!orderedSpreads.has(segments) || first?.kind !== "spread" || first.value === undefined)
@@ -1307,6 +1554,12 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
     const siteOf = (e) => {
         if (e.kind === "seqExpr" && e.result.kind === "recordLit")
             prologues.set(e.result, e.stmts);
+        // A kept width spread's literal now initializes its own declaration, but
+        // it still evaluates the spread's source binding in the wrapper's
+        // prologue (keepWidthSpreads).
+        const host = keptLiteralStmts.get(e);
+        if (host !== undefined && e.kind === "recordLit")
+            prologues.set(e, host);
         if (e.kind === "recordLit" && e.type.kind === "record" && variants.has(e.type.shapeId)) {
             const list = sites.get(e.type.shapeId) ?? [];
             list.push(e);
@@ -1436,7 +1689,7 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         return indexOfOrder(orders, complete(resolved.order.filter((k) => keys.has(k)), orders[0]));
     };
     const plan = new Map();
-    const dropped = new Set();
+    const dropped = new Set(keptDropShapes);
     for (const [id, list] of sites) {
         for (const lit of list) {
             const index = orderIndex(id, lit);
@@ -1591,4 +1844,292 @@ export function applyKeyOrderWitnesses(lowerer, fns) {
         shape.orderVariants = tables;
     }
 }
+/** The replacements recorded for `fn`. */
+function replacementsIn(byFn, fn) {
+    let replacements = byFn.get(fn);
+    if (replacements === undefined)
+        byFn.set(fn, (replacements = new Map()));
+    return replacements;
+}
+/** Replaces each node of `replacements` in `fn` through the node that holds
+ * it (replaceChildExpr), and the nodes under a replacement in turn. A node
+ * is never rewritten into another kind in place: the compiler compiles this
+ * file too, and a node it builds keeps its kind's fields. */
+function replaceThroughParents(fn, replacements) {
+    if (replacements.size === 0)
+        return;
+    let replaced = 0;
+    const children = (parent) => ({
+        expr: (child) => {
+            const to = replacements.get(child);
+            if (to !== undefined && replaceChildExpr(parent, child, to))
+                replaced++;
+            visitExpr(to ?? child);
+            return true;
+        },
+        stmt: (child) => {
+            visitStmt(child);
+            return true;
+        },
+    });
+    function visitExpr(node) {
+        const { expr, stmt } = children(node);
+        everyExprChild(node, expr, stmt);
+    }
+    function visitStmt(node) {
+        const { expr, stmt } = children(node);
+        everyStmtChild(node, expr, stmt);
+    }
+    for (const stmt of fn.body)
+        visitStmt(stmt);
+    if (replaced !== replacements.size)
+        throw new InternalCompilerError(`key-order-witness: ${replacements.size - replaced} kept site(s) not found in ${fn.name}`);
+}
+/** Width spreads: `{ ...wide }` into a narrower declared record. Node's copy
+ * holds every own key of the source; the static copy holds the declared
+ * ones. When an order surface can observe the target shape (the same
+ * observation the order tables use), the literal keeps the copy's whole
+ * own-key list as the record's kept source (scr_record_source_note): each
+ * spread source's own keys are snapshot as the spread runs, explicit keys
+ * hold placeholders at their position, and the record stays the source of
+ * truth for every declared key. Programs no surface observes keep the
+ * static copy byte for byte. */
+function widthKeepable(lowerer, wrapper, width) {
+    return width.every((segment) => segment.kind === "key" ||
+        ((segment.value.type.kind === "dyn" || lowerer.dynConvertible(segment.value.type)) &&
+            wrapper.stmts.some((stmt) => stmt.kind === "varDecl" && stmt.localId === segment.value.localId)));
+}
+function keepWidthSpreads(notes, sites, kept, rewritten) {
+    let index = 0;
+    for (const { wrapper, literal, fn, note } of sites) {
+        if (!kept.has(wrapper) || rewritten.has(wrapper))
+            continue;
+        rewritten.add(wrapper);
+        notes.keptWidthSpreads++;
+        const width = note.segments;
+        const loc = literal.loc;
+        const site = index++;
+        const empty = () => ({ kind: "dynObjLit", fields: [], type: DYN, loc });
+        const assign = (target, from) => ({
+            kind: "libCall",
+            fn: "dyn.assign",
+            args: [target, from],
+            type: DYN,
+            loc,
+        });
+        let mirror = empty();
+        let spreadIndex = 0;
+        for (const segment of width) {
+            if (segment.kind === "key") {
+                mirror = assign(mirror, {
+                    kind: "dynObjLit",
+                    fields: [{ key: strLit(segment.name, loc), value: dynUndefinedExpr(loc) }],
+                    type: DYN,
+                    loc,
+                });
+                continue;
+            }
+            // The spread copies the source's own keys when it runs: snapshot them
+            // right after the literal evaluated the source.
+            const localId = `%widthKeys.${site}.${spreadIndex++}`;
+            fn.locals.push({ id: localId, name: "%widthKeys", type: DYN, mutable: false });
+            const boxed = segment.value.type.kind === "dyn"
+                ? segment.value
+                : { kind: "dynFrom", value: segment.value, liveRef: true, type: DYN, loc };
+            const at = wrapper.stmts.findIndex((stmt) => stmt.kind === "varDecl" && stmt.localId === segment.value.localId);
+            wrapper.stmts.splice(at + 1, 0, {
+                kind: "varDecl",
+                localId,
+                init: assign(empty(), boxed),
+                loc,
+            });
+            mirror = assign(mirror, { kind: "varRef", localId, type: DYN, loc });
+        }
+        const builtId = `%widthKept.${site}`;
+        fn.locals.push({ id: builtId, name: "%widthKept", type: literal.type, mutable: false });
+        const built = { kind: "varRef", localId: builtId, type: literal.type, loc };
+        wrapper.stmts.push({ kind: "varDecl", localId: builtId, init: literal, loc }, {
+            kind: "exprStmt",
+            expr: { kind: "libCall", fn: "record.sourceNote", args: [built, mirror], type: VOID, loc },
+            loc,
+        });
+        wrapper.result = built;
+    }
+}
+/** Whether a value of this type reaches a record layout that holds a kept
+ * source: a plain record a checked conversion builds or an earlier kept
+ * copy's shape, or a union with such an arm. */
+function reachesKeptSource(lowerer, type, converted) {
+    if (type.kind === "record")
+        return (recordMayKeepSource(lowerer, type) &&
+            (converted.has(type.shapeId) || lowerer.keyOrder.keptSourceShapes.has(type.shapeId)));
+    if (type.kind === "union")
+        return (lowerer.unions.get(type.unionId)?.arms ?? []).some((arm) => reachesKeptSource(lowerer, arm, converted));
+    return false;
+}
+/** Add the record shapes a checked conversion's target can hold a source
+ * in: the target itself when it is a plain record, or the records nested in
+ * a union arm, an array element, a promise or an index signature's values
+ * (the layouts the checked builder notes sources for). */
+function conversionShapes(lowerer, target, out, seen) {
+    if (target.kind === "promise")
+        return conversionShapes(lowerer, target.inner, out, seen);
+    if (target.kind === "array")
+        return conversionShapes(lowerer, target.elem, out, seen);
+    if (target.kind === "record") {
+        if (seen.has(target.shapeId))
+            return;
+        seen.add(target.shapeId);
+        // A conversion builds the records of its nested fields too, each with
+        // its own kept source.
+        if (recordMayKeepSource(lowerer, target))
+            out.add(target.shapeId);
+        const shape = lowerer.shapes.get(target.shapeId);
+        for (const field of shape?.fields ?? [])
+            conversionShapes(lowerer, field.type, out, seen);
+        if (shape?.indexValue !== undefined)
+            conversionShapes(lowerer, shape.indexValue, out, seen);
+        return;
+    }
+    if (target.kind !== "union" || seen.has(target.unionId))
+        return;
+    seen.add(target.unionId);
+    for (const arm of lowerer.unions.get(target.unionId)?.arms ?? [])
+        conversionShapes(lowerer, arm, out, seen);
+}
+/** `"k" in r` over a closed record answers statically false for a literal
+ * key the shape does not declare. A kept source can hold it (a checked
+ * conversion's undeclared keys, a width spread's extras), so when the
+ * program keeps record sources the site answers through the record's own
+ * kept view instead. The receiver evaluates exactly once, as the static
+ * form evaluated it. */
+function keepSourceProbes(lowerer, notes, sites, possible) {
+    if (!possible)
+        return;
+    let index = 0;
+    const byFn = new Map();
+    for (const { node, fn } of sites) {
+        const probe = notes.sourceProbeOf(node);
+        if (probe === undefined)
+            continue;
+        const recT = probe.receiver.type;
+        if (recT.kind !== "record")
+            continue;
+        if (!recordMayKeepSource(lowerer, recT))
+            continue;
+        const loc = node.loc;
+        const id = `%inSource.${index++}`;
+        fn.locals.push({ id, name: "%inSource", type: recT, mutable: false });
+        const ref = { kind: "varRef", localId: id, type: recT, loc };
+        const replacement = {
+            kind: "seqExpr",
+            stmts: [{ kind: "varDecl", localId: id, init: probe.receiver, loc }],
+            result: {
+                kind: "logical",
+                op: "&&",
+                left: recordSourceTest(ref, loc),
+                right: {
+                    kind: "dynHasKey",
+                    key: probe.key,
+                    value: { kind: "dynFrom", value: ref, liveRef: true, type: DYN, loc },
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            },
+            type: BOOL,
+            loc,
+        };
+        replacementsIn(byFn, fn).set(node, replacement);
+    }
+    for (const [fn, replacements] of byFn)
+        replaceThroughParents(fn, replacements);
+}
+/** Same-shape `{ ...r, k: v }` clones: Node's copy holds every own key of
+ * the source, and the recordClone fast path copies the declared fields
+ * only. A clone over a shape that can keep a source, in a program that
+ * keeps one, snapshots the source's own keys and notes them on the built
+ * record; the overrides keep their source position (a placeholder for an
+ * existing key keeps its place, a new one follows the source's keys). The
+ * override values still evaluate after the source, as before. */
+function keepRecordClones(lowerer, sites, kept) {
+    let index = 0;
+    const byFn = new Map();
+    for (const { node, fn } of sites) {
+        if (!kept.has(node) || node.kind !== "recordClone")
+            continue;
+        const cloneT = node.type;
+        if (cloneT.kind !== "record" || !recordMayKeepSource(lowerer, cloneT))
+            continue;
+        const loc = node.loc;
+        const n = index++;
+        const srcId = `%cloneSrc.${n}`;
+        const keysId = `%cloneKeys.${n}`;
+        const builtId = `%cloneKept.${n}`;
+        fn.locals.push({ id: srcId, name: "%cloneSrc", type: node.source.type, mutable: false });
+        fn.locals.push({ id: keysId, name: "%cloneKeys", type: DYN, mutable: false });
+        fn.locals.push({ id: builtId, name: "%cloneKept", type: cloneT, mutable: false });
+        const srcRef = { kind: "varRef", localId: srcId, type: node.source.type, loc };
+        const assign = (target, from) => ({
+            kind: "libCall",
+            fn: "dyn.assign",
+            args: [target, from],
+            type: DYN,
+            loc,
+        });
+        const placeholder = (name) => ({
+            kind: "dynObjLit",
+            fields: [{ key: strLit(name, loc), value: dynUndefinedExpr(loc) }],
+            type: DYN,
+            loc,
+        });
+        let mirror = { kind: "varRef", localId: keysId, type: DYN, loc };
+        for (const override of node.overrides)
+            mirror = assign(mirror, placeholder(override.name));
+        const built = { kind: "varRef", localId: builtId, type: cloneT, loc };
+        const overrides = node.overrides;
+        const replacement = {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "varDecl", localId: srcId, init: node.source, loc },
+                {
+                    kind: "varDecl",
+                    localId: keysId,
+                    init: assign({ kind: "dynObjLit", fields: [], type: DYN, loc }, {
+                        kind: "dynFrom",
+                        value: srcRef,
+                        liveRef: true,
+                        type: DYN,
+                        loc,
+                    }),
+                    loc,
+                },
+                {
+                    kind: "varDecl",
+                    localId: builtId,
+                    init: { kind: "recordClone", source: srcRef, overrides, type: cloneT, loc },
+                    loc,
+                },
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "record.sourceNote",
+                        args: [built, mirror],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            result: built,
+            type: cloneT,
+            loc,
+        };
+        replacementsIn(byFn, fn).set(node, replacement);
+    }
+    for (const [fn, replacements] of byFn)
+        replaceThroughParents(fn, replacements);
+}
 //# sourceMappingURL=key-order-witness.js.map