@scriptc/compiler 0.4.8 → 0.4.9

package/dist/frontend/lowering/containers/indexed-objects.js

@@ -899,6 +899,44 @@ export function recordOvfCapturePlan(lowerer, fromId, toId) {
  * index-signature record arm) builds this same helper through
  * recordOvfCapturePlan. */
 export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
+    return buildRecordCaptureHelper(lowerer, fromId, toId, loc, {
+        key: `ovf:${fromId}:${toId}`,
+        namePrefix: "%rec.capture",
+        excluded: EMPTY_CAPTURE_EXCLUSION,
+        propagateNullProto: true,
+        keepSourceTail: true,
+    });
+}
+/** Interned `%rec.rest.<n>(s)` — the fresh object `const { a, x, ...rest } =
+ * s` binds over an INDEX-SIGNATURE source (or into an index-signature rest
+ * type): the capture reshape with an explicit EXCLUSION set, which is the
+ * one thing JavaScript's CopyDataProperties does differently from a plain
+ * reshape. Declared target fields the two shapes share are direct-copied
+ * (presence kept), every other source declared field is keyed-written in
+ * declaration order, and the source overflow is copied in JS own-key order
+ * — each skipping an excluded literal key. The result is always a fresh
+ * object with `Object.prototype` (a rest copy never inherits its source's
+ * null prototype), so `nullProto` is not propagated. Null when the pair is
+ * outside the matrix (recordOvfCapturePlan's gates), when the rest type
+ * declares an excluded name (never a rest type tsc produces), or when the
+ * source could keep an out-of-shape view that the field-by-field rebuild
+ * cannot see — the caller keeps its named fence for those. */
+export function lowerRecordRestCaptureHelper(lowerer, fromId, toId, excluded, loc) {
+    const names = [...new Set(excluded)].sort();
+    return buildRecordCaptureHelper(lowerer, fromId, toId, loc, {
+        // The set is part of the key, spelled so that two DIFFERENT sets can
+        // never produce one spelling: a property name may hold a comma
+        // (`{ "a,b": x, ...rest }` beside `{ a, b, ...rest }`) or be empty,
+        // and either would join into the other set's text.
+        key: `rest:${fromId}:${toId}:${JSON.stringify(names)}`,
+        namePrefix: "%rec.rest",
+        excluded: new Set(names),
+        propagateNullProto: false,
+        keepSourceTail: false,
+    });
+}
+const EMPTY_CAPTURE_EXCLUSION = new Set();
+function buildRecordCaptureHelper(lowerer, fromId, toId, loc, opts) {
     const plan = recordOvfCapturePlan(lowerer, fromId, toId);
     if (!plan)
         return null;
@@ -910,16 +948,28 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
     const tIv = to.indexValue;
     if (tIv === undefined)
         return null;
+    const { excluded, propagateNullProto } = opts;
+    if (excluded.size > 0 && to.fields.some((f) => excluded.has(f.name)))
+        return null;
+    // A rest reshape over a CLOSED source that can keep an out-of-shape view
+    // cannot see that view's keys, and the checked-conversion tail would
+    // carry the excluded ones back in — decline (the caller keeps its named
+    // fence).
+    if (!opts.keepSourceTail &&
+        fIv === null &&
+        recordMayKeepSource(lowerer, { kind: "record", shapeId: fromId }))
+        return null;
     // The copy below writes the source's declared fields in order, so a
     // program that reaches it observes that order (the plan itself is pure:
     // a speculative widthLiftPlan call must not mark a shape observed).
     lowerer.keyOrder.observed.add(from.id);
-    const { inits, fieldLifts, orderedFields, consumed } = plan;
-    const key = `ovf:${fromId}:${toId}`;
+    const { fieldLifts, orderedFields, consumed } = plan;
+    const inits = excluded.size === 0 ? plan.inits : plan.inits.filter((d) => !excluded.has(d.name));
+    const key = opts.key;
     const existing = lowerer.valueHelpers.get(key);
     if (existing)
         return existing;
-    const name = keyedHelperName(lowerer, "%rec.capture", key);
+    const name = keyedHelperName(lowerer, opts.namePrefix, key);
     lowerer.valueHelpers.set(key, name);
     const fromT = { kind: "record", shapeId: fromId };
     const toT = { kind: "record", shapeId: toId };
@@ -940,7 +990,7 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
                     field: d.name,
                     type: d.src,
                     loc,
-                }, to.fields.find((f) => f.name === d.name).type, loc), loc)
+                }, to.fields.find((f) => f.name === d.name).type, loc), loc, to.fields.find((f) => f.name === d.name))
                 : {
                     // No source property of this name: the field starts
                     // absent (an overflow write below can supply it).
@@ -955,7 +1005,7 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
     };
     // The source and its reshape are one object in JavaScript, so a
     // null-prototype source (a match's groups, Object.groupBy) keeps it.
-    const init = nullProtoRecordShape(lowerer, fromT) && nullProtoRecordShape(lowerer, toT)
+    const init = propagateNullProto && nullProtoRecordShape(lowerer, fromT) && nullProtoRecordShape(lowerer, toT)
         ? {
             kind: "ternary",
             cond: recordNullProtoTest(sRef, fromId, loc),
@@ -970,7 +1020,7 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
     // Source declared fields in declaration order, skipping unset
     // optionals (stance 37) and the direct-initialized (consumed) names.
     for (const ff of orderedFields) {
-        if (consumed.has(ff.name))
+        if (consumed.has(ff.name) || excluded.has(ff.name))
             continue;
         const raw = {
             kind: "recordGet",
@@ -1005,10 +1055,43 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
         body.push(fieldStmt);
     }
     // The source overflow, in JS own-key order (only index-signature
-    // sources carry one).
+    // sources carry one). A rest reshape skips the excluded literal keys
+    // here (a strEq chain against the key literal), which is what removes
+    // the consumed entries from the fresh object.
     const ksT = arrayOf(STRING);
     if (fIv) {
         const ovfLift = plan.ovfLift;
+        const ovfWrite = {
+            kind: "recordKeySet",
+            obj: outRef,
+            shapeId: toId,
+            key: varRef("k.0", STRING, loc),
+            value: intoSlot({
+                kind: "recordKeyGet",
+                obj: sRef,
+                shapeId: fromId,
+                key: varRef("k.0", STRING, loc),
+                overflowOnly: true,
+                type: fIv,
+                loc,
+            }, ovfLift),
+            loc,
+        };
+        let notExcluded = null;
+        for (const name of [...excluded].sort()) {
+            const test = {
+                kind: "strEq",
+                negated: true,
+                left: varRef("k.0", STRING, loc),
+                right: { kind: "strLit", value: name, type: STRING, loc },
+                type: BOOL,
+                loc,
+            };
+            notExcluded =
+                notExcluded === null
+                    ? test
+                    : { kind: "logical", op: "&&", left: notExcluded, right: test, type: BOOL, loc };
+        }
         body.push({
             kind: "varDecl",
             localId: "ks.0",
@@ -1034,22 +1117,9 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
                 },
                 loc,
             },
-            {
-                kind: "recordKeySet",
-                obj: outRef,
-                shapeId: toId,
-                key: varRef("k.0", STRING, loc),
-                value: intoSlot({
-                    kind: "recordKeyGet",
-                    obj: sRef,
-                    shapeId: fromId,
-                    key: varRef("k.0", STRING, loc),
-                    overflowOnly: true,
-                    type: fIv,
-                    loc,
-                }, ovfLift),
-                loc,
-            },
+            notExcluded === null
+                ? ovfWrite
+                : { kind: "if", cond: notExcluded, then: [ovfWrite], else_: null, loc },
         ]));
     }
     // A CLOSED source can still hold own keys its shape does not declare: a
@@ -1066,7 +1136,8 @@ export function lowerRecordOvfCaptureHelper(lowerer, fromId, toId, loc) {
     // and the view can only exist if the program converts something into a
     // closed record at all. Both facts are settled before the shape helpers
     // finalize their bodies, so the tail is chosen there.
-    const sourcedFromView = fIv === null &&
+    const sourcedFromView = opts.keepSourceTail &&
+        fIv === null &&
         recordMayKeepSource(lowerer, fromT) &&
         canDynCheckTo(toT, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id));
     body.push({ kind: "return", value: outRef, loc });
@@ -1168,9 +1239,28 @@ export function lowerObjectAssignIndexShape(lowerer, call) {
             return "dyn";
         return lowerer.widthLiftPlan(t, tIv);
     };
+    // A dyn source's values arrive untyped, so each one enters the target's
+    // index-value slot through a CHECKED conversion: a value outside the
+    // slot throws the catchable TypeError where JS stores it (SEMANTICS.md's
+    // cast divergence, the same stance every dyn→typed conversion takes). A
+    // runtime key can collide with a DECLARED target field, and the keyed
+    // write stores a non-dyn value through such a slot unchecked — so those
+    // fields must be the slot type (or, for a dyn slot, dyn-convertible).
+    const dynSourceOpen = tIv.kind === "dyn"
+        ? to.fields.every((f) => lowerer.dynConvertible(f.type))
+        : canDynCheckTo(tIv, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)) && to.fields.every((f) => typeEquals(f.type, tIv));
     const plans = [];
     for (const argNode of call.arguments.nodes.slice(1)) {
         const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
+        if (srcIr?.kind === "dyn") {
+            // The target keeps its typed representation while the checker's
+            // `T & U` answer for a dyn `U` is some other type, so only the
+            // mutate-in-place spelling (result discarded) can be lowered.
+            if (!discarded || !dynSourceOpen)
+                return null;
+            plans.push({ kind: "dyn" });
+            continue;
+        }
         if (srcIr?.kind !== "record")
             return null;
         const from = lowerer.shapes.get(srcIr.shapeId);
@@ -1198,7 +1288,7 @@ export function lowerObjectAssignIndexShape(lowerer, call) {
             if (ovfLift === null)
                 return null;
         }
-        plans.push({ fromId: srcIr.shapeId, fields, ovfLift });
+        plans.push({ kind: "record", fromId: srcIr.shapeId, fields, ovfLift });
     }
     const helperFor = (plan) => {
         const key = `assign:${targetIr.shapeId}:${plan.fromId}`;
@@ -1331,13 +1421,106 @@ export function lowerObjectAssignIndexShape(lowerer, call) {
         lowerer.liftedFns.push(fn);
         return name;
     };
+    /** Interned `%obj.assignDyn.<n>(t, s)` — the same keyed-write walk for a
+     * source with no static shape: `Object.keys(s)` own-key order (what
+     * `Object.assign` copies), each value read back through the key and
+     * checked into the target's index-value slot by the keyed write. A
+     * null/undefined source copies nothing, exactly JS's rule that
+     * `Object.assign` SKIPS such sources (where `Object.keys` would throw). */
+    const dynHelperFor = () => {
+        const key = `assign:${targetIr.shapeId}:dyn`;
+        const existing = lowerer.valueHelpers.get(key);
+        if (existing)
+            return existing;
+        const name = keyedHelperName(lowerer, "%obj.assignDyn", key);
+        lowerer.valueHelpers.set(key, name);
+        const toT = { kind: "record", shapeId: targetIr.shapeId };
+        const tRef = varRef("t.0", toT, loc);
+        const sRef = varRef("s.0", DYN, loc);
+        const ksT = arrayOf(STRING);
+        const kRef = varRef("k.0", STRING, loc);
+        const read = { kind: "dynKeyGet", key: kRef, value: sRef, type: DYN, loc };
+        const value = tIv.kind === "dyn" ? read : { kind: "dynCheck", value: read, type: tIv, loc };
+        const fn = {
+            name,
+            params: [
+                { localId: "t.0", name: "t", type: toT },
+                { localId: "s.0", name: "s", type: DYN },
+            ],
+            returnType: toT,
+            locals: [
+                { id: "t.0", name: "t", type: toT, mutable: true },
+                { id: "s.0", name: "s", type: DYN, mutable: false },
+                { id: "ks.0", name: "ks", type: ksT, mutable: false },
+                { id: "i.0", name: "i", type: F64, mutable: true },
+                { id: "k.0", name: "k", type: STRING, mutable: false },
+            ],
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "dynTest", test: "nullish", value: sRef, type: BOOL, loc },
+                    then: [{ kind: "return", value: tRef, loc }],
+                    else_: [
+                        {
+                            kind: "varDecl",
+                            localId: "ks.0",
+                            init: {
+                                kind: "libCall",
+                                fn: "dyn.objKeyStrings",
+                                args: [sRef],
+                                type: ksT,
+                                loc,
+                            },
+                            loc,
+                        },
+                        countedFor(loc, {
+                            kind: "arrIntrinsic",
+                            method: "length",
+                            receiver: varRef("ks.0", ksT, loc),
+                            args: [],
+                            type: F64,
+                            loc,
+                        }, () => [
+                            {
+                                kind: "varDecl",
+                                localId: "k.0",
+                                init: {
+                                    kind: "arrayGet",
+                                    arr: varRef("ks.0", ksT, loc),
+                                    index: varRef("i.0", F64, loc),
+                                    type: STRING,
+                                    loc,
+                                },
+                                loc,
+                            },
+                            {
+                                kind: "recordKeySet",
+                                obj: tRef,
+                                shapeId: targetIr.shapeId,
+                                key: kRef,
+                                value,
+                                loc,
+                            },
+                        ]),
+                    ],
+                    loc,
+                },
+                { kind: "return", value: tRef, loc },
+            ],
+            loc,
+        };
+        lowerer.liftedFns.push(fn);
+        return name;
+    };
     let acc = lowerer.lowerExprExpecting(call.arguments.nodes[0], targetIr);
     for (let i = 0; i < plans.length; i++) {
-        const src = lowerer.lowerExprExpecting(call.arguments.nodes[i + 1], {
-            kind: "record",
-            shapeId: plans[i].fromId,
-        });
-        acc = { kind: "call", callee: helperFor(plans[i]), args: [acc, src], type: targetIr, loc };
+        const plan = plans[i];
+        const argNode = call.arguments.nodes[i + 1];
+        const src = plan.kind === "dyn"
+            ? lowerer.coerceToExpected(lowerer.lowerExpr(argNode), DYN)
+            : lowerer.lowerExprExpecting(argNode, { kind: "record", shapeId: plan.fromId });
+        const callee = plan.kind === "dyn" ? dynHelperFor() : helperFor(plan);
+        acc = { kind: "call", callee, args: [acc, src], type: targetIr, loc };
     }
     return acc;
 }