@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -95,6 +95,11 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             probedUntyped = true;
         }
     }
+    if (receiverIr?.kind === "union") {
+        const unionHof = lowerArrayUnionHofCall(lowerer, call, access, receiverIr);
+        if (unionHof)
+            return unionHof;
+    }
     if (receiverIr?.kind !== "array")
         return null;
     if (!probedUntyped && !lowerer.isStdlibMember(access))
@@ -541,7 +546,7 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
     }
     // Preserve the existing fast path for an ordinary, non-union needle. Its
     // runtime implementation already has exact primitive/reference equality.
-    if (elem.kind !== "union" && typeEquals(needle.type, elem)) {
+    if (elem.kind !== "union" && elem.kind !== "bigint" && typeEquals(needle.type, elem)) {
         return {
             kind: "arrIntrinsic",
             method,
@@ -828,6 +833,18 @@ function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
         }
         lowerer.implicitParamTypes = previousImplicit;
     }
+    // Array storage widens indexed reads with undefined so holes remain
+    // observable. The HOF helper guards every callback behind arrayHas,
+    // so an exact-ABI builtin closure may safely adapt from its declared
+    // parameter to that guarded union. Keep this exception scoped to the
+    // compiler-generated builtin values; ordinary callback-value policy is
+    // unchanged.
+    if (fnArg.type.kind === "func" && lowerer.isBuiltinCallableValue(fnArg)) {
+        const callbackType = funcOf(full.slice(0, fnArg.type.params.length), fnArg.type.ret);
+        if (!typeEquals(fnArg.type, callbackType)) {
+            fnArg = lowerer.coerceToExpected(fnArg, callbackType);
+        }
+    }
     if (fnArg.type.kind !== "func" ||
         fnArg.type.params.length > full.length ||
         !fnArg.type.params.every((p, i) => typeEquals(p, full[i]))) {
@@ -986,8 +1003,9 @@ function truthyFilterCallback(lowerer, valueT, 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. */
+ * the reference kinds have constant or by-value answers, checked-dynamic
+ * values ask their runtime kind, and a union is fine when every arm does.
+ * void/jsval/caught stay out — see below. */
 function filterPredicateOk(lowerer, ret) {
     if (ret.kind === "bool")
         return true;
@@ -997,10 +1015,13 @@ function filterPredicateOk(lowerer, ret) {
     // 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.
+    // A checked-dynamic value retains its runtime kind, so scr_dyn_truthy can
+    // apply JavaScript ToBoolean exactly. Island and caught values stay out.
     if (ret.kind === "void")
         return false;
-    if (ret.kind === "dyn" || ret.kind === "jsval" || ret.kind === "caught")
+    if (ret.kind === "dyn")
+        return true;
+    if (ret.kind === "jsval" || ret.kind === "caught")
         return false;
     if (ret.kind === "union") {
         const def = lowerer.unions.get(ret.unionId);
@@ -1020,9 +1041,9 @@ function filterCond(call, fnRet, loc) {
     // `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.
+    // unsafe union arms (dyn/caught) at the call site, where a real node
+    // exists for the diagnostic. A bare dyn value is handled directly by
+    // the runtime's kind-aware ToBoolean.
     return { kind: "toBool", operand: call, type: BOOL, loc };
 }
 /** Interned synthetic loop function for one (method, elem, fnRet, arity)
@@ -1039,6 +1060,139 @@ function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRe
     lowerer.liftedFns.push(buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem));
     return name;
 }
+/** The TS 5.2+ callable-union array rule: a `T[] | U[]` receiver exposes
+ * common HOFs with a callback over `T | U`. The runtime value remains the
+ * original concrete array arm — never a copied `(T | U)[]` — and an
+ * arm-specific function adapter wraps the element and receiver arguments
+ * into the union-wide callback ABI. That preserves sparse-array reads,
+ * callback mutation, and the callback's third-argument identity. */
+function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
+    const method = access.name.text;
+    if (method !== "map" && method !== "forEach")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const def = lowerer.unions.get(receiverT.unionId);
+    if (!def || def.arms.length < 2 || !def.arms.every((arm) => arm.kind === "array"))
+        return null;
+    if (call.arguments.length !== 1 || !call.arguments[0])
+        return null;
+    const arrays = def.arms;
+    const valueArms = [];
+    const addValueArm = (type) => {
+        if (type.kind === "dyn" || type.kind === "jsval" || type.kind === "caught" || type.kind === "void")
+            return false;
+        if (type.kind === "union") {
+            const inner = lowerer.unions.get(type.unionId);
+            if (!inner)
+                return false;
+            for (const arm of inner.arms) {
+                if (!valueArms.some((candidate) => typeEquals(candidate, arm)))
+                    valueArms.push(arm);
+            }
+            return true;
+        }
+        if (!valueArms.some((candidate) => typeEquals(candidate, type)))
+            valueArms.push(type);
+        return true;
+    };
+    for (const array of arrays) {
+        if (!addValueArm(array.elem))
+            return null;
+    }
+    const valueT = valueArms.length === 1
+        ? valueArms[0]
+        : { kind: "union", unionId: lowerer.unions.intern(valueArms) };
+    const argNode = call.arguments[0];
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [valueT], receiverT);
+    const fnRet = fnArg.type.ret;
+    if (method === "map" && (fnRet.kind === "void" || fnRet.kind === "func")) {
+        lowerer.badType(call, lowerer.typeOf(call));
+    }
+    if (method === "map")
+        fenceProducedArrayElem(lowerer, call, "'.map()'", fnRet);
+    const outElem = method === "map" ? callbackArrayElem(lowerer, call, fnRet) : VOID;
+    const resultT = method === "map" ? arrayOf(outElem) : VOID;
+    for (const array of arrays) {
+        const armFnT = funcOf([arrayValueType(lowerer, array.elem), F64, array].slice(0, arity), fnRet);
+        if (!lowerer.cleanFuncAdaptable(fnArg.type, armFnT))
+            return null;
+    }
+    const helper = arrayUnionHofHelper(lowerer, method, receiverT, arrays, fnArg.type, arity, fnRet, outElem, locOf(call));
+    return {
+        kind: "call",
+        callee: helper,
+        args: [lowerer.coerceInto(access.expression, lowerer.lowerExpr(access.expression), receiverT), fnArg],
+        type: resultT,
+        loc: locOf(call),
+    };
+}
+function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arity, fnRet, outElem, loc) {
+    const resultT = method === "map" ? arrayOf(outElem) : VOID;
+    const key = `union:${method}:${receiverT.unionId}:${typeKey(callbackT)}:${typeKey(resultT)}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%arr.union.${lowerer.arrHofHelpers.size}`;
+    lowerer.arrHofHelpers.set(key, name);
+    const receiver = varRef("a.0", receiverT, loc);
+    const callback = varRef("f.0", callbackT, loc);
+    const branch = (array) => {
+        const tag = lowerer.armTag(receiverT.unionId, array);
+        const concrete = {
+            kind: "unionNarrow",
+            unionId: receiverT.unionId,
+            tag,
+            value: receiver,
+            type: array,
+            loc,
+        };
+        const armFnT = funcOf([arrayValueType(lowerer, array.elem), F64, array].slice(0, arity), fnRet);
+        const adapted = lowerer.coerceToExpected(callback, armFnT);
+        if (!typeEquals(adapted.type, armFnT)) {
+            throw new InternalCompilerError("lowerer bug: union-array callback stopped adapting");
+        }
+        const callee = arrayHofHelper(lowerer, method, array.elem, fnRet, arity, loc, outElem);
+        const invoke = { kind: "call", callee, args: [concrete, adapted], type: resultT, loc };
+        return resultT.kind === "void"
+            ? [{ kind: "exprStmt", expr: invoke, loc }, { kind: "return", value: null, loc }]
+            : [{ kind: "return", value: invoke, loc }];
+    };
+    let body = branch(arrays[arrays.length - 1]);
+    for (let i = arrays.length - 2; i >= 0; i--) {
+        const array = arrays[i];
+        body = [{
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: receiverT.unionId,
+                    tag: lowerer.armTag(receiverT.unionId, array),
+                    negated: false,
+                    value: receiver,
+                    type: BOOL,
+                    loc,
+                },
+                then: branch(array),
+                else_: body,
+                loc,
+            }];
+    }
+    lowerer.liftedFns.push({
+        name,
+        params: [
+            { localId: "a.0", name: "a", type: receiverT },
+            { localId: "f.0", name: "f", type: callbackT },
+        ],
+        returnType: resultT,
+        locals: [
+            { id: "a.0", name: "a", type: receiverT, mutable: false },
+            { id: "f.0", name: "f", type: callbackT, mutable: false },
+        ],
+        body,
+        loc,
+    });
+    return name;
+}
 /** READ-ONLY array methods on TUPLE receivers — `t.slice(...)` and
    * `t.map(f)`: a tuple is a fixed-shape record, but these methods never
    * write, so the positions snapshot into a fresh array (the for-of-over-