@scriptc/compiler 0.4.7 → 0.4.8

package/dist/frontend/lowering/containers/array-callbacks.js

@@ -38,6 +38,7 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode) ?? undefined);
     const present = !booleanFilter && presentElements(lowerer, call, elem);
     const valueT = callbackValueType(lowerer, elem, present);
+    const thisArg = hofThisArg(lowerer, call);
     if (booleanFilter) {
         if (valueT.kind === "union")
             lowerer.requireTruthyUnion(valueT.unionId, argNode);
@@ -82,15 +83,19 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
     const outElem = filtered !== null ? filtered.elem : callbackArrayElement(lowerer, call, fnRet);
     // A filter that re-tags its elements keeps the single union-typed visit.
     // A callback that never reads its element has no use for a typed one.
-    const fast = present || booleanFilter || unread || (method === "filter" && !typeEquals(outElem, elem))
+    const fast = present ||
+        booleanFilter ||
+        unread ||
+        thisArg !== null ||
+        (method === "filter" && !typeEquals(outElem, elem))
         ? null
         : lowerFastCallback(lowerer, argNode, [valueT], 0, elem, arrayOf(elem), callback);
-    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
+    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread, thisArg !== null);
     const resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
     const result = {
         kind: "call",
         callee: helper,
-        args: [receiver, fnArg, ...(fast ? [fast] : [])],
+        args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
         type: resultType,
         loc,
     };
@@ -105,6 +110,20 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         loc,
     };
 }
+/** The thisArg of a callback HOF call (`a.map(f, thisArg)`), lowered as the
+ * checked-dynamic value the helper hands the callback as its call-site
+ * receiver. Null when the call has no second argument, in which case the
+ * helper keeps the two-slot frame and the callback's `this` is the ambient
+ * one, exactly as before. */
+function hofThisArg(lowerer, call) {
+    const node = call.arguments.nodes[1];
+    if (node === undefined)
+        return null;
+    if (call.arguments.nodes.length > 2) {
+        lowerer.noLowering(`.${ts.isPropertyAccessExpression(call.expression) ? call.expression.name.text : ""} with ${call.arguments.nodes.length} arguments`, call, "the supported form takes the callback and an optional thisArg");
+    }
+    return lowerer.lowerExprExpecting(node, DYN);
+}
 /** The element a filter keeps, and the checked conversion of the result
  * to the checker's narrower element when the predicate does not prove it.
  * An inferred inline type predicate proves one source arm, or a class
@@ -452,8 +471,8 @@ const FILTER_SNAPSHOT = { isForeign: "vf.0", value: "v.0", foreign: "vd.0" };
  * combo. Named `%arr.<method>.<n>` ('%' keeps it out of the user
  * namespace); rides `liftedFns` into the module like a lifted lambda (it
  * is a plain function — no captures). */
-function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null, present = false, unread = false) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null, present = false, unread = false, withThis = false) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -469,7 +488,7 @@ function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRe
         split: !!fastT,
         unread,
     });
-    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present, unread);
+    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present, unread, withThis);
     lowerer.liftedFns.push(fastT ? withFastCallback(fn, fastT, elem) : fn);
     return name;
 }
@@ -706,13 +725,13 @@ function filterRetainedValue(lowerer, v, elem, outElem, loc) {
  * `arity` is the callback's declared parameter count (1–3): the loop
  * passes the index and the receiver itself after the element when the
  * callback names them, exactly the arguments JS supplies. */
-function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null, present = false, unread = false) {
+function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null, present = false, unread = false, withThis = false) {
     const arrT = arrayOf(elem);
     const valueT = callbackValueType(lowerer, elem, present);
     const fnT = funcOf([valueT, F64, arrT].slice(0, arity), fnRet);
-    const locals = arrayCallbackLocals(arrT, fnT);
-    const params = arrayCallbackParams(arrT, fnT);
-    const callF = (arg) => callArrayCallback(arrT, fnT, fnRet, arity, arg, loc);
+    const locals = arrayCallbackLocals(arrT, fnT, withThis);
+    const params = arrayCallbackParams(arrT, fnT, withThis);
+    const callF = (arg) => callArrayCallback(arrT, fnT, fnRet, arity, arg, loc, withThis);
     const getElem = callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc);
     // What the callback takes: the element, or a placeholder for one it
     // ignores (callbackValueRead's `unread`).
@@ -981,6 +1000,7 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
+    const thisArg = hofThisArg(lowerer, call);
     // find's result must be reachable from the element itself; a predicate
     // that narrows to another layout keeps the optional element visit.
     const present = presentElements(lowerer, call, elem) &&
@@ -1004,17 +1024,17 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
         method === "every" ||
         method === "findIndex" ||
         method === "findLastIndex") {
-        const fast = present || unread
+        const fast = present || unread || thisArg !== null
             ? null
             : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity }, bindUntyped);
         const fastT = fast?.type ?? null;
         const helper = method === "findIndex" || method === "findLastIndex"
-            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT, present, unread)
-            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT, present, unread);
+            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT, present, unread, thisArg !== null)
+            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT, present, unread, thisArg !== null);
         return {
             kind: "call",
             callee: helper,
-            args: [receiver, fnArg, ...(fast ? [fast] : [])],
+            args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
             type: method === "findIndex" || method === "findLastIndex" ? F64 : BOOL,
             loc,
         };
@@ -1036,8 +1056,14 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     if (undefTag < 0)
         lowerer.badType(call, lowerer.typeOf(call));
     const retag = findResultRetag(lowerer, call, argNode, method, valueT, resultT, unchangedElement);
-    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg), present, unread);
-    return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
+    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg), present, unread, thisArg !== null);
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg, ...(thisArg ? [thisArg] : [])],
+        type: resultT,
+        loc,
+    };
 }
 /** The retag helper that converts a found element into find's result union,
  * or null when the element converts directly. Only an inline callback with
@@ -1091,9 +1117,9 @@ export function predicateToBoolean(e) {
  *   for (i = 0; i < n; i++) { v = a[i]; if (f(v)) return <v as result arm>; }
  *   return <undefined arm>;
  */
-function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "", present = false, unread = false) {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "", present = false, unread = false, withThis = false) {
     const method = last ? "findLast" : "find";
-    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1130,7 +1156,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
             ...arraySlotSnapshot(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, FILTER_SNAPSHOT, loc),
             {
                 kind: "if",
-                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, placeholder ?? v, loc)),
+                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, placeholder ?? v, loc, withThis)),
                 then: [
                     {
                         kind: "return",
@@ -1146,7 +1172,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
             read,
             {
                 kind: "if",
-                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, v, loc)),
+                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, v, loc, withThis)),
                 then: [{ kind: "return", value: found, loc }],
                 else_: null,
                 loc,
@@ -1163,10 +1189,10 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
     ];
     lowerer.liftedFns.push({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: resultT,
         locals: [
-            ...arrayCallbackLocals(arrT, fnT),
+            ...arrayCallbackLocals(arrT, fnT, withThis),
             { id: "v.0", name: "v", type: valueT, mutable: false },
             ...(ignored
                 ? slotSnapshotLocals(lowerer, elem, FILTER_SNAPSHOT).filter((l) => l.id !== "v.0")
@@ -1194,9 +1220,9 @@ function findFoundValue(lowerer, v, resultT, retag, loc) {
  *
  *   n = a.length; for (...) if (f(a[i], i, a)) return i;  return -1;
  */
-function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null, present = false, unread = false) {
+function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null, present = false, unread = false, withThis = false) {
     const method = last ? "findLastIndex" : "findIndex";
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1218,7 +1244,7 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
     const visit = [
         {
             kind: "if",
-            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc)),
+            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc, withThis)),
             then: [{ kind: "return", value: varRef("i.0", F64, loc), loc }],
             else_: null,
             loc,
@@ -1234,9 +1260,9 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
     ];
     lowerer.liftedFns.push(withFastCallback({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: F64,
-        locals: [...arrayCallbackLocals(arrT, fnT)],
+        locals: [...arrayCallbackLocals(arrT, fnT, withThis)],
         body,
         loc,
     }, fastT, elem));
@@ -1247,8 +1273,8 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
  *   some:  n = a.length; for (...) if (f(a[i])) return true;  return false;
  *   every: n = a.length; for (...) if (!f(a[i])) return false; return true;
  */
-function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false, withThis = false) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1266,7 +1292,7 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fa
     });
     const arrT = arrayOf(elem);
     const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
-    const callF = predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc));
+    const callF = predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc, withThis));
     const body = [
         arrayLengthDeclaration(arrT, loc),
         countedFor(loc, varRef("n.0", F64, loc), () => [
@@ -1292,9 +1318,9 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fa
     ];
     lowerer.liftedFns.push(withFastCallback({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: BOOL,
-        locals: [...arrayCallbackLocals(arrT, fnT)],
+        locals: [...arrayCallbackLocals(arrT, fnT, withThis)],
         body,
         loc,
     }, fastT, elem));
@@ -1313,6 +1339,7 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
+    const thisArg = hofThisArg(lowerer, call);
     const present = presentElements(lowerer, call, elem);
     const lowered = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT);
     const { fnArg, arity } = lowered;
@@ -1327,7 +1354,7 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             recv: { kind: "dynFrom", value: receiver, liveRef: true, type: DYN, loc },
             method: "flatMap",
             calleeName: ts.getTextOfNode(access),
-            args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }],
+            args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }, ...(thisArg ? [thisArg] : [])],
             type: DYN,
             loc,
         };
@@ -1338,11 +1365,11 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             ? flatMapUnionPlan(lowerer, call, argNode, fnRet)
             : null;
         if (plan) {
-            const helper = flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present);
+            const helper = flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present, thisArg !== null);
             return {
                 kind: "call",
                 callee: helper,
-                args: [receiver, fnArg],
+                args: [receiver, fnArg, ...(thisArg ? [thisArg] : [])],
                 type: arrayOf(plan.outElem),
                 loc,
             };
@@ -1358,32 +1385,32 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             lowerer.badType(call, lowerer.typeOf(call));
         requireProducedArrayElement(lowerer, call, "'.flatMap()'", fnRet);
         const outElem = callbackArrayElement(lowerer, call, fnRet);
-        const fast = present || unread
+        const fast = present || unread || thisArg !== null
             ? null
             : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
                 fnArg,
                 arity,
             });
-        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
+        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread, thisArg !== null);
         return {
             kind: "call",
             callee: helper,
-            args: [receiver, fnArg, ...(fast ? [fast] : [])],
+            args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
             type: arrayOf(outElem),
             loc,
         };
     }
-    const fast = present || unread
+    const fast = present || unread || thisArg !== null
         ? null
         : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
             fnArg,
             arity,
         });
-    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
+    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread, thisArg !== null);
     return {
         kind: "call",
         callee: helper,
-        args: [receiver, fnArg, ...(fast ? [fast] : [])],
+        args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
         type: fnRet,
         loc,
     };
@@ -1453,10 +1480,10 @@ function flatMapUnionPlan(lowerer, call, argNode, fnRet) {
 /** The flatMap loop over a union-returning callback: each result tests
  * its arm and appends its elements, nothing, or itself (Node's
  * IsArray decision per value). */
-function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
+function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present, withThis = false) {
     // The plan is part of the key: one union result type can carry an empty
     // `never[]` arm in one callback and a populated array arm in another.
-    const key = `flatMapUnion:${typeKey(elem)}:${typeKey(fnRet)}:${typeKey(plan.outElem)}:${plan.arms.join(",")}:${arity}${present ? ":present" : ""}`;
+    const key = `flatMapUnion:${typeKey(elem)}:${typeKey(fnRet)}:${typeKey(plan.outElem)}:${plan.arms.join(",")}:${arity}${present ? ":present" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1477,7 +1504,7 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
         loc,
     });
     const locals = [
-        ...arrayCallbackLocals(arrT, fnT),
+        ...arrayCallbackLocals(arrT, fnT, withThis),
         { id: "out.0", name: "out", type: outT, mutable: false },
         { id: "r.0", name: "r", type: fnRet, mutable: false },
     ];
@@ -1622,7 +1649,7 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
                     {
                         kind: "varDecl",
                         localId: "r.0",
-                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc),
+                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc, withThis),
                         loc,
                     },
                     ...dispatch,
@@ -1635,7 +1662,7 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
     ];
     lowerer.liftedFns.push({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: outT,
         locals,
         body,
@@ -1652,8 +1679,8 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
  *   }
  *   return out;
  */
-function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false) {
-    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false, withThis = false) {
+    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1738,7 +1765,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
                     {
                         kind: "varDecl",
                         localId: "r.0",
-                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc),
+                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc, withThis),
                         loc,
                     },
                     {
@@ -1764,10 +1791,10 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
     ];
     lowerer.liftedFns.push(withFastCallback({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: fnRet,
         locals: [
-            ...arrayCallbackLocals(arrT, fnT),
+            ...arrayCallbackLocals(arrT, fnT, withThis),
             { id: "out.0", name: "out", type: fnRet, mutable: false },
             { id: "r.0", name: "r", type: fnRet, mutable: false },
             { id: "m.0", name: "m", type: F64, mutable: false },
@@ -1792,19 +1819,46 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const hasInit = call.arguments.nodes.length === 2;
-    const accT = lowerer.runtimeOptionalReduceTypes.get(call) ??
-        (hasInit ? lowerer.irTypeOf(call) : arrayValueType(lowerer, elem));
-    if (accT.kind === "void" || accT.kind === "func")
+    const overrideT = lowerer.runtimeOptionalReduceTypes.get(call) ?? null;
+    const staticAccT = overrideT ?? (hasInit ? lowerer.irTypeOf(call) : arrayValueType(lowerer, elem));
+    if (staticAccT.kind === "void" || staticAccT.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
-    const lowered = lowerArrayCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT, false, accT);
+    const lowered = lowerArrayCallback(lowerer, argNode, [staticAccT, arrayValueType(lowerer, elem)], arrT, false, staticAccT);
     const { fnArg, arity } = lowered;
+    // A JavaScript function with NO declared parameters whose body reads
+    // `arguments` has that hidden slot as its whole ABI, which the synthetic
+    // loop cannot fill: `callValue` passes exactly the declared parameters
+    // (none), so the callback would see an empty `arguments` where JavaScript
+    // passes (accumulator, element, index, array). Name the parameters
+    // instead; that is the same value with a checkable type. Read the
+    // callback's OWN type: the slot adaptation above (a dyn function boundary)
+    // erases the hidden slot from `fnArg.type`. A callback that names its
+    // parameters keeps working — `arguments` is built from the call's
+    // arguments there, not from a hidden slot.
+    if (lowered.rawType.kind === "func" &&
+        lowered.rawType.params.length === 0 &&
+        lowered.rawType.rest === true &&
+        lowered.rawType.restAbi === undefined)
+        lowerer.unsupported("SC1090", argNode, "a reduce callback that reads 'arguments' (name the parameters the callback uses)");
+    // The callback's own answer is what the accumulator receives. An inline
+    // lambda is contextually typed by the call (its returns coerce inside its
+    // own lowering), but a function DECLARATION keeps its declared return. When
+    // the checker's accumulator type cannot hold that value — `xs.reduce(function
+    // () { count++ }, 1)` answers undefined, a program the checker already
+    // diagnosed — the accumulator is the checked-dynamic value JavaScript
+    // produces instead of a miscast (the untyped-reduce shape; see
+    // accumulatorAdmitsAnswer).
+    const accT = overrideT !== null || accumulatorAdmitsAnswer(lowerer, staticAccT, fnArg.type.ret)
+        ? staticAccT
+        : DYN;
     // Only an array that can hold elements outside its element type needs to
-    // leave an element its callback ignores unread.
+    // leave an element its callback ignores unread. A dynamic accumulator is
+    // the untyped shape; it keeps the single visit and the callback's own ABI.
     const unread = lowered.unread && elementMayBeForeign(lowerer, elem);
-    const fast = unread
+    const fast = unread || accT.kind === "dyn"
         ? null
         : lowerFastCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], 1, elem, arrT, { fnArg, arity }, false, accT);
-    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, unread);
+    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type, hasInit, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, unread);
     const args = [receiver, fnArg];
     if (hasInit)
         args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], accT));
@@ -1814,6 +1868,33 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
         args.push(fast);
     return { kind: "call", callee: helper, args, type: accT, loc };
 }
+/** The accumulator's value as the callback's first parameter declares it.
+ * Equal types pass the local straight through; a dynamic accumulator handed
+ * to a typed parameter converts at the call (the callback is lowered first,
+ * so its ABI is a fact and a value of another kind throws — "types don't
+ * lie"). */
+function accumulatorArgument(lowerer, param, accT, loc) {
+    const value = varRef("acc.0", accT, loc);
+    return param === undefined || typeEquals(param, accT)
+        ? value
+        : lowerer.coerceToExpected(value, param);
+}
+/** Whether the checker's accumulator type stores the callback's answer
+ * itself. A scalar accumulator holds only its own scalar, and a void answer
+ * (a callback with no return statement) is `undefined`; both leave the
+ * checker's type unable to carry the value (a program the checker already
+ * diagnosed), which the reduction accumulates dynamically instead of
+ * miscasting. Every other pair keeps `coerceToExpected`'s static plan. */
+function accumulatorAdmitsAnswer(lowerer, accT, fnRet) {
+    if (lowerer.coercibleValue(fnRet, accT))
+        return true;
+    if (fnRet.kind === "void" || isUnitType(fnRet))
+        return false;
+    return !(scalarKind(accT) && scalarKind(fnRet));
+}
+function scalarKind(t) {
+    return t.kind === "f64" || t.kind === "string" || t.kind === "bool";
+}
 /** The reduce/reduceRight loops, from existing IR nodes:
  *
  *   with init:    acc = z; n = a.length; for (...) acc = f(acc, a[i]); return acc;
@@ -1824,14 +1905,23 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
  * reduce walks 0→n-1, reduceRight n-1→0; the seed without an initial
  * value is a[0] / a[n-1] and the loop starts one past it. The empty-array
  * TypeError message is Node's exact message. */
-function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, site = "", fastT = null, unread = false) {
+function reduceHelper(lowerer, method, elem, accT, fnArg, hasInit, loc, site = "", fastT = null, unread = false) {
+    // The callback's own ABI decides the helper's `f` slot: a dynamic
+    // accumulator (accT) is coerced at the call and the store, so the closure
+    // keeps the parameter types its lowering produced.
+    const fnT = fnArg;
+    const fnRet = fnT.ret;
+    const arity = fnT.params.length;
     const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}${unread ? ":unread" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
-    if (method === "reduce")
+    // A dynamic accumulator stays out of the pipeline registry: the fused
+    // loops type their accumulator from the checker's view (arrHofInfo), which
+    // this shape contradicts.
+    if (method === "reduce" && accT.kind !== "dyn")
         lowerer.arrHofInfo.set(name, {
             method,
             elem,
@@ -1844,7 +1934,6 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
             unread,
         });
     const arrT = arrayOf(elem);
-    const fnT = funcOf([accT, arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const n = varRef("n.0", F64, loc);
     const i = varRef("i.0", F64, loc);
     const right = method === "reduceRight";
@@ -1961,7 +2050,12 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
                         value: lowerer.coerceToExpected({
                             kind: "callValue",
                             callee: varRef("f.0", fnT, loc),
-                            args: [varRef("acc.0", accT, loc), visited(), i, varRef("a.0", arrT, loc)].slice(0, arity),
+                            args: [
+                                accumulatorArgument(lowerer, fnT.params[0], accT, loc),
+                                visited(),
+                                i,
+                                varRef("a.0", arrT, loc),
+                            ].slice(0, arity),
                             type: fnRet,
                             loc,
                         }, accT),