@scriptc/compiler 0.0.31 → 0.0.33

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,