@scriptc/compiler 0.0.32 → 0.0.34

package/dist/frontend/lowering/lower-containers.js

@@ -8,7 +8,7 @@ import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS, STR_METHO
 import { droppableStatic, isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
-import { DYN_DISPATCH_METHODS, islandPrimitiveExit } from "./lower-calls.js";
+import { islandPrimitiveExit, lowerDynDispatchMethodCall } from "./lower-calls.js";
 import { typeKey } from "../types.js";
 import { dynUndefinedExpr, own } from "./lowerer.js";
 /** Lower an expression whose checker type is statically `undefined`/`void`.
@@ -142,7 +142,11 @@ export function lowerArrayMethodCall(L, call, access) {
     {
         const receiver = L.lowerExpr(access.expression);
         if (receiver.type.kind === "jsval") {
-            const args = call.arguments.map((a) => L.jsvalIn(L.lowerExpr(a), a));
+            const loweredArgs = call.arguments.map((a) => L.lowerExpr(a));
+            if (name === "filter" && loweredArgs[0]?.type.kind === "func" && loweredArgs[0].type.ret.kind === "void") {
+                L.unsupported("SC1090", call.arguments[0], "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
+            }
+            const args = loweredArgs.map((arg, i) => L.jsvalIn(arg, call.arguments[i]));
             const result = { kind: "jsOp", op: "callMethod", name, args: [receiver, ...args], type: JSVAL, loc };
             return islandPrimitiveExit(L, call, result);
         }
@@ -155,21 +159,9 @@ export function lowerArrayMethodCall(L, call, access) {
         // ICE). Consumers validate the dyn result where a static type is
         // required (dynCheck — the member-read discipline).
         if (receiver.type.kind === "dyn") {
-            if (DYN_DISPATCH_METHODS.has(name) && !call.questionDotToken && !access.questionDotToken) {
-                if (call.arguments.some((a) => ts.isSpreadElement(a))) {
-                    L.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
-                }
-                const args = call.arguments.map((a) => L.lowerExprExpecting(a, DYN));
-                return {
-                    kind: "dynInvoke",
-                    recv: receiver,
-                    method: name,
-                    calleeName: access.getText(),
-                    args,
-                    type: DYN,
-                    loc,
-                };
-            }
+            const dispatched = lowerDynDispatchMethodCall(L, call, access, receiver, true);
+            if (dispatched)
+                return dispatched;
             L.noLowering(`.${name} on an array value held in a checked-dynamic binding`, call, "assign it to an array-typed binding first (the validated extraction), then call the method");
         }
         // An evolving-`any` array binding under --dynamic whose flow type
@@ -596,12 +588,64 @@ export function lowerArrayHofCall(L, call, access, method, elem) {
         // declaration, so the honest answer is the fence).
         L.unsupported("SC1090", call, "'.map()' with a callback returning 'unknown'-typed values (the result array has no static element type — annotate the callback's return)");
     }
-    if (method === "filter" && fnRet.kind !== "bool")
+    // JS applies ToBoolean to whatever the predicate answers, so a non-bool
+    // result is not an error — the filter loop wraps the call in the same
+    // toBool an `if` statement would apply. The island/dyn shapes, whose
+    // truthiness needs the engine, and void, whose real answer the ABI has
+    // already discarded, keep the fence. No separate
+    // requireTruthyUnion call belongs here: its check (no dyn/caught arm)
+    // IS filterPredicateOk's union branch, so it could never speak.
+    if (method === "filter" && !filterPredicateOk(L, fnRet)) {
+        if (fnRet.kind === "void") {
+            L.unsupported("SC1090", argNode, "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
+        }
         L.badType(argNode, L.typeOf(argNode));
+    }
     const helper = arrayHofHelper(L, method, elem, fnRet, arity, loc);
     const resultType = method === "map" ? arrayOf(fnRet) : method === "filter" ? arrayOf(elem) : VOID;
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultType, loc };
 }
+/** The predicate result kinds `.filter()` accepts. JS applies ToBoolean to
+ * whatever the callback answers, so a bool is not required: the scalars and
+ * the reference kinds have constant or by-value answers, and a union is fine
+ * when every arm does. void/dyn/jsval/caught stay out — see below. */
+function filterPredicateOk(L, ret) {
+    if (ret.kind === "bool")
+        return true;
+    // VOID is a TYPE erasure, not a runtime value: TS lets a value-returning
+    // function sit in a void-returning slot (`const p: (n: number) => void =
+    // (n) => n`), so the predicate's real answer can be truthy while the
+    // compiled ABI has already discarded it. Treating void as constantly
+    // falsy would silently answer [] where Node answers [1]. Fenced until
+    // the returned value can be preserved through the void ABI.
+    // dyn/jsval/caught stay out too: no native ToBoolean to compile against.
+    if (ret.kind === "void")
+        return false;
+    if (ret.kind === "dyn" || ret.kind === "jsval" || ret.kind === "caught")
+        return false;
+    if (ret.kind === "union") {
+        const def = L.unions.get(ret.unionId);
+        return def !== undefined && def.arms.every((a) => a.kind !== "dyn" && a.kind !== "caught");
+    }
+    return true;
+}
+/** The filter loop's condition: the predicate's result put through JS
+ * ToBoolean. A bool answer is already the condition; everything else takes
+ * the same `toBool` wrapper an `if` statement would apply (a union answer
+ * routes through its interned per-arm truthy helper). */
+function filterCond(call, fnRet, loc) {
+    if (fnRet.kind === "bool")
+        return call;
+    // No constant-false arm here: void is fenced at the call site, and a
+    // bare undefinedT/nullT return cannot arise (mapType sends `undefined`/
+    // `void` returns to void and a standalone `null` return to the unit-ONLY
+    // UNION, which routes through toBool below; ir/validate.ts rejects a
+    // bare unit return type outright). filterPredicateOk already rejected
+    // the arms with no native ToBoolean (dyn/caught) — which is exactly what
+    // requireTruthyUnion checks — and it did so at the call site, where a
+    // real node exists for the diagnostic.
+    return { kind: "toBool", operand: call, type: BOOL, loc };
+}
 /** Interned synthetic loop function for one (method, elem, fnRet, arity)
    * combo. Named `%arr.<method>.<n>` ('%' keeps it out of the user
    * namespace); rides `liftedFns` into the module like a lifted lambda (it
@@ -934,7 +978,9 @@ export function buildArrayHofFn(L, name, method, elem, fnRet, arity, loc) {
                 { kind: "varDecl", localId: "v.0", init: getElem, loc },
                 {
                     kind: "if",
-                    cond: callF(ref("v.0", elem)),
+                    // ToBoolean over the predicate's answer — inert when it already
+                    // returned bool, the per-union helper when it returned a union.
+                    cond: filterCond(callF(ref("v.0", elem)), fnRet, loc),
                     then: [push(arrT, ref("v.0", elem))],
                     else_: null,
                     loc,
@@ -5808,6 +5854,7 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
         const body = [
             { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
         ];
+        const fieldStmts = new Map();
         // Declared fields, in declaration order. Undefined-valued fields
         // skip at runtime (the unset-optional convention); values surface
         // into the element type or the site fences with the field named.
@@ -5875,7 +5922,7 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
                             loc,
                         };
             }
-            body.push(utag >= 0 && f.type.kind === "union"
+            const fieldStmt = utag >= 0 && f.type.kind === "union"
                 ? {
                     kind: "if",
                     cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: utag, negated: true, value: raw, type: BOOL, loc },
@@ -5883,7 +5930,9 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
                     else_: null,
                     loc,
                 }
-                : push(pushed));
+                : push(pushed);
+            fieldStmts.set(f.name, fieldStmt);
+            body.push(fieldStmt);
         }
         // The overflow walk: a fresh key snapshot in JS own-key order, each
         // value read back through the overflow-only keyed read (declared
@@ -5930,8 +5979,9 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
             ],
             loc,
         }, { kind: "return", value: outRef, loc });
+        const suffix = body.slice(1 + fieldStmts.size);
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push({
+        const fn = {
             name: helper,
             params: [{ localId: "r.0", name: "r", type: argIr }],
             returnType: resultT,
@@ -5944,7 +5994,16 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
             ],
             body,
             loc,
+        };
+        L.shapeOrderHelperFinalizers.push(() => {
+            const current = L.shapes.get(argIr.shapeId) ?? shape;
+            const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
+            fn.body = [body[0], ...currentOrder.flatMap((name) => {
+                    const stmt = fieldStmts.get(name);
+                    return stmt ? [stmt] : [];
+                }), ...suffix];
         });
+        L.liftedFns.push(fn);
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
@@ -6310,6 +6369,7 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             loc,
         },
     ];
+    const fieldStmts = new Map();
     // Source declared fields in declaration order, skipping unset
     // optionals (stance 37) and the direct-initialized (consumed) names.
     for (const ff of orderedFields) {
@@ -6328,7 +6388,7 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             ...(to.fields.some((f) => f.name === ff.name) ? {} : { overflowOnly: true }),
             loc,
         };
-        body.push(utag >= 0 && ff.type.kind === "union"
+        const fieldStmt = utag >= 0 && ff.type.kind === "union"
             ? {
                 kind: "if",
                 cond: { kind: "unionIsTag", unionId: ff.type.unionId, tag: utag, negated: true, value: raw, type: BOOL, loc },
@@ -6336,7 +6396,9 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
                 else_: null,
                 loc,
             }
-            : write);
+            : write;
+        fieldStmts.set(ff.name, fieldStmt);
+        body.push(fieldStmt);
     }
     // The source overflow, in JS own-key order (only index-signature
     // sources carry one).
@@ -6375,7 +6437,8 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
         });
     }
     body.push({ kind: "return", value: outRef, loc });
-    L.liftedFns.push({
+    const suffix = body.slice(1 + fieldStmts.size);
+    const fn = {
         name,
         params: [{ localId: "s.0", name: "s", type: fromT }],
         returnType: toT,
@@ -6392,7 +6455,16 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
         ],
         body,
         loc,
+    };
+    L.shapeOrderHelperFinalizers.push(() => {
+        const current = L.shapes.get(fromId) ?? from;
+        const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
+        fn.body = [body[0], ...currentOrder.flatMap((field) => {
+                const stmt = fieldStmts.get(field);
+                return stmt ? [stmt] : [];
+            }), ...suffix];
     });
+    L.liftedFns.push(fn);
     return name;
 }
 /** `Object.assign(target, ...sources)` into an INDEX-SIGNATURE record:
@@ -6485,6 +6557,7 @@ export function lowerObjectAssignIndexShape(L, call) {
         const sRef = ref("s.0", fromT);
         const intoSlot = (v, lift) => lift === "dyn" ? { kind: "dynFrom", value: v, type: DYN, loc } : L.applyWidthLift(lift, v, tIv, loc);
         const body = [];
+        const fieldStmts = new Map();
         for (const ff of plan.fields) {
             const raw = { kind: "recordGet", obj: sRef, shapeId: plan.fromId, field: ff.name, type: ff.type, loc };
             const utag = ff.type.kind === "union" ? L.armTag(ff.type.unionId, UNDEFINED_T) : -1;
@@ -6496,7 +6569,7 @@ export function lowerObjectAssignIndexShape(L, call) {
                 value: intoSlot(raw, ff.lift),
                 loc,
             };
-            body.push(utag >= 0 && ff.type.kind === "union"
+            const fieldStmt = utag >= 0 && ff.type.kind === "union"
                 ? {
                     kind: "if",
                     cond: { kind: "unionIsTag", unionId: ff.type.unionId, tag: utag, negated: true, value: raw, type: BOOL, loc },
@@ -6504,7 +6577,9 @@ export function lowerObjectAssignIndexShape(L, call) {
                     else_: null,
                     loc,
                 }
-                : write);
+                : write;
+            fieldStmts.set(ff.name, fieldStmt);
+            body.push(fieldStmt);
         }
         const ksT = arrayOf(STRING);
         const fromShape = L.shapes.get(plan.fromId);
@@ -6542,7 +6617,8 @@ export function lowerObjectAssignIndexShape(L, call) {
             });
         }
         body.push({ kind: "return", value: tRef, loc });
-        L.liftedFns.push({
+        const suffix = body.slice(fieldStmts.size);
+        const fn = {
             name,
             params: [
                 { localId: "t.0", name: "t", type: toT },
@@ -6562,7 +6638,16 @@ export function lowerObjectAssignIndexShape(L, call) {
             ],
             body,
             loc,
+        };
+        L.shapeOrderHelperFinalizers.push(() => {
+            const current = L.shapes.get(plan.fromId) ?? fromShape;
+            const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
+            fn.body = [...currentOrder.flatMap((field) => {
+                    const stmt = fieldStmts.get(field);
+                    return stmt ? [stmt] : [];
+                }), ...suffix];
         });
+        L.liftedFns.push(fn);
         return name;
     };
     let acc = L.lowerExprExpecting(call.arguments[0], targetIr);