@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -8,7 +8,7 @@ import { PoisonError } from "../lowerer.js";
 import { BOOL, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isSortValuesElement, isUnitType, typeEquals, } from "../../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import { buildArraySortFn, buildSortKeyFn, closureKeyOrder, sortKeysId, sortKeysOrder, } from "../lower-array-sort.js";
-import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent, primitiveElement, } from "../array-values.js";
+import { arrayIndexPresent, arraySlotSnapshot, arraySnapshotAppend, arraySnapshotValue, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent, elementMayBeForeign, foreignElementThrow, primitiveElement, slotSnapshotLocals, unreadArgument, } from "../array-values.js";
 import { typeKey } from "../../type-mapper.js";
 import { lowerArrayCallback, requireProducedArrayElement, callbackArrayElement, truthyFilterCallback, } from "./callback-arguments.js";
 import { reverseArrayLoop, arrayLengthDeclaration, arrayCallbackParams, arrayCallbackLocals, callArrayCallback, } from "./array-iteration.js";
@@ -47,14 +47,19 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         }
     }
     const callback = booleanFilter
-        ? { fnArg: truthyFilterCallback(lowerer, valueT, loc), arity: 1 }
+        ? { fnArg: truthyFilterCallback(lowerer, valueT, loc), arity: 1, unread: false }
         : lowerArrayCallback(lowerer, argNode, [valueT], arrayOf(elem));
     const { fnArg, arity } = callback;
+    // Only an array that can hold elements outside its element type needs to
+    // leave an element its callback ignores unread.
+    const unread = callback.unread && !present && elementMayBeForeign(lowerer, elem);
     const fnRet = fnArg.type.ret;
-    if (method === "map" && (fnRet.kind === "void" || fnRet.kind === "func")) {
-        // The result array U[] is unrepresentable here (no void elements;
-        // the map helper's closure-returning form has no fixture-backed
-        // story yet).
+    if (method === "map" && fnRet.kind === "void") {
+        // The result array `void[]` is unrepresentable: a void return value is
+        // erased before it could be stored. A CLOSURE-returning callback is an
+        // ordinary function element — the value is one ScrClosure for its whole
+        // life, stored by reference with the element kind's `_v` adapter and
+        // trace, exactly like a closure array literal (`[() => 1]`).
         lowerer.badType(call, lowerer.typeOf(call));
     }
     if (method === "map")
@@ -75,10 +80,11 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         : null;
     const outElem = filtered !== null ? filtered.elem : callbackArrayElement(lowerer, call, fnRet);
     // A filter that re-tags its elements keeps the single union-typed visit.
-    const fast = present || booleanFilter || (method === "filter" && !typeEquals(outElem, elem))
+    // A callback that never reads its element has no use for a typed one.
+    const fast = present || booleanFilter || unread || (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);
+    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
     const resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
     const result = {
         kind: "call",
@@ -416,24 +422,41 @@ function presentElements(lowerer, call, elem) {
 function callbackValueType(lowerer, elem, present) {
     return present ? elem : arrayValueType(lowerer, elem);
 }
-function callbackValueRead(lowerer, arr, index, elem, present, loc) {
+function callbackValueRead(lowerer, arr, index, elem, present, loc, unread = false) {
+    if (unread) {
+        const placeholder = unreadArgument(lowerer, callbackValueType(lowerer, elem, present), loc);
+        if (placeholder)
+            return placeholder;
+    }
     return present
         ? { kind: "arrayGet", arr, index, type: elem, loc }
         : arrayValueRead(lowerer, arr, index, elem, loc);
 }
+/** The snapshot locals of the filter and find helpers; `value` is their
+ * element local `v.0`. */
+const FILTER_SNAPSHOT = { isForeign: "vf.0", value: "v.0", foreign: "vd.0" };
 /** 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
  * is a plain function — no captures). */
-function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null, present = false) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
+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" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
-    lowerer.arrHofInfo.set(name, { method, elem, fnRet, arity, outElem, present, split: !!fastT });
-    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present);
+    lowerer.arrHofInfo.set(name, {
+        method,
+        elem,
+        fnRet,
+        arity,
+        outElem,
+        present,
+        split: !!fastT,
+        unread,
+    });
+    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present, unread);
     lowerer.liftedFns.push(fastT ? withFastCallback(fn, fastT, elem) : fn);
     return name;
 }
@@ -483,7 +506,8 @@ export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
     const argNode = call.arguments.nodes[0];
     const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [valueT], receiverT);
     const fnRet = fnArg.type.ret;
-    if (method === "map" && (fnRet.kind === "void" || fnRet.kind === "func")) {
+    if (method === "map" && fnRet.kind === "void") {
+        // `void[]` has no element (see the plain-receiver map path).
         lowerer.badType(call, lowerer.typeOf(call));
     }
     if (method === "map")
@@ -608,7 +632,7 @@ 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) {
+function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null, present = false, unread = false) {
     const arrT = arrayOf(elem);
     const valueT = callbackValueType(lowerer, elem, present);
     const fnT = funcOf([valueT, F64, arrT].slice(0, arity), fnRet);
@@ -616,6 +640,11 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
     const params = arrayCallbackParams(arrT, fnT);
     const callF = (arg) => callArrayCallback(arrT, fnT, fnRet, arity, arg, loc);
     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`).
+    const argElem = unread
+        ? callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, true)
+        : getElem;
     const hasElem = {
         kind: "arrayHas",
         arr: varRef("a.0", arrT, loc),
@@ -660,7 +689,7 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
                     kind: "if",
                     cond: hasElem,
                     then: [
-                        { kind: "varDecl", localId: "mapped.0", init: callF(getElem), loc },
+                        { kind: "varDecl", localId: "mapped.0", init: callF(argElem), loc },
                         arrayValueStore(lowerer, varRef("out.0", outT, loc), method === "map"
                             ? varRef("i.0", F64, loc)
                             : {
@@ -778,6 +807,16 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
         locals.push({ id: "out.0", name: "out", type: outT, mutable: false }, { id: "v.0", name: "v", type: valueT, mutable: false });
         returnType = outT;
         const retained = filterRetainedValue(lowerer, varRef("v.0", valueT, loc), elem, outElem, loc);
+        // A predicate that ignores the element of an array that can hold
+        // elements outside its element type keeps a snapshot of the slot, read
+        // before the predicate runs, as stored (arraySlotSnapshot).
+        const copied = (arity === 0 || unread) &&
+            !present &&
+            typeEquals(outElem, elem) &&
+            elementMayBeForeign(lowerer, elem);
+        // `v.0` is declared above; the snapshot adds its other two locals.
+        if (copied)
+            locals.push(...slotSnapshotLocals(lowerer, elem, FILTER_SNAPSHOT).filter((l) => l.id !== "v.0"));
         body = [
             {
                 kind: "varDecl",
@@ -790,27 +829,42 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
                 {
                     kind: "if",
                     cond: hasElem,
-                    then: [
-                        { kind: "varDecl", localId: "v.0", init: getElem, loc },
-                        {
-                            kind: "if",
-                            // ToBoolean over the predicate's answer — inert when it already
-                            // returned bool, the per-union helper when it returned a union.
-                            cond: filterCond(callF(varRef("v.0", valueT, loc)), fnRet, loc),
-                            then: [
-                                arrayValueStore(lowerer, varRef("out.0", outT, loc), {
-                                    kind: "arrIntrinsic",
-                                    method: "length",
-                                    receiver: varRef("out.0", outT, loc),
-                                    args: [],
-                                    type: F64,
-                                    loc,
-                                }, retained, outElem, loc),
-                            ],
-                            else_: null,
-                            loc,
-                        },
-                    ],
+                    // A kept element is appended as it was stored, so one the element
+                    // type cannot hold stays in the result.
+                    then: copied
+                        ? [
+                            ...arraySlotSnapshot(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, FILTER_SNAPSHOT, loc),
+                            {
+                                kind: "if",
+                                cond: filterCond(callF(argElem), fnRet, loc),
+                                then: [
+                                    arraySnapshotAppend(lowerer, varRef("out.0", outT, loc), elem, FILTER_SNAPSHOT, loc),
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ]
+                        : [
+                            { kind: "varDecl", localId: "v.0", init: getElem, loc },
+                            {
+                                kind: "if",
+                                // ToBoolean over the predicate's answer — inert when it already
+                                // returned bool, the per-union helper when it returned a union.
+                                cond: filterCond(callF(varRef("v.0", valueT, loc)), fnRet, loc),
+                                then: [
+                                    arrayValueStore(lowerer, varRef("out.0", outT, loc), {
+                                        kind: "arrIntrinsic",
+                                        method: "length",
+                                        receiver: varRef("out.0", outT, loc),
+                                        args: [],
+                                        type: F64,
+                                        loc,
+                                    }, retained, outElem, loc),
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ],
                     else_: null,
                     loc,
                 },
@@ -826,7 +880,7 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
                 {
                     kind: "if",
                     cond: hasElem,
-                    then: [{ kind: "exprStmt", expr: callF(getElem), loc }],
+                    then: [{ kind: "exprStmt", expr: callF(argElem), loc }],
                     else_: null,
                     loc,
                 },
@@ -858,7 +912,11 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     const present = presentElements(lowerer, call, elem) &&
         ((method !== "find" && method !== "findLast") ||
             (!bindUntyped && lowerer.coercibleValue(elem, lowerer.irTypeOf(call))));
-    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT, bindUntyped);
+    const lowered = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT, bindUntyped);
+    const { fnArg, arity } = lowered;
+    // Only an array that can hold elements outside its element type needs to
+    // leave an element its callback ignores unread.
+    const unread = lowered.unread && !present && elementMayBeForeign(lowerer, elem);
     // JS takes the ToBoolean of the predicate's result — allowed wherever
     // that ToBoolean has a static answer (bool passes through; f64/string
     // by value; a truthy-answerable union by its arm — the
@@ -872,13 +930,13 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
         method === "every" ||
         method === "findIndex" ||
         method === "findLastIndex") {
-        const fast = present
+        const fast = present || unread
             ? 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)
-            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT, present);
+            ? 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);
         return {
             kind: "call",
             callee: helper,
@@ -904,7 +962,7 @@ 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);
+    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 };
 }
 /** The retag helper that converts a found element into find's result union,
@@ -959,9 +1017,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) {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "", present = false, unread = false) {
     const method = last ? "findLast" : "find";
-    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -980,21 +1038,46 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
         type: resultT,
         loc,
     };
-    const visitBody = [
-        {
-            kind: "varDecl",
-            localId: "v.0",
-            init: callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc),
-            loc,
-        },
-        {
-            kind: "if",
-            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, v, loc)),
-            then: [{ kind: "return", value: found, loc }],
-            else_: null,
-            loc,
-        },
-    ];
+    const read = {
+        kind: "varDecl",
+        localId: "v.0",
+        init: callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc),
+        loc,
+    };
+    // A predicate that ignores the element of an array that can hold
+    // elements outside its element type keeps a snapshot of the slot, read
+    // before the predicate runs as JavaScript reads it (arraySlotSnapshot):
+    // the predicate is called without reading it as typed, and a found element
+    // outside the element type takes the checked conversion into the result.
+    const ignored = (arity === 0 || unread) && !present && elementMayBeForeign(lowerer, elem);
+    const placeholder = unread ? unreadArgument(lowerer, valueT, loc) : null;
+    const visitBody = ignored
+        ? [
+            ...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)),
+                then: [
+                    {
+                        kind: "return",
+                        value: arraySnapshotValue(lowerer, elem, FILTER_SNAPSHOT, resultT, () => found, loc),
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            },
+        ]
+        : [
+            read,
+            {
+                kind: "if",
+                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, v, loc)),
+                then: [{ kind: "return", value: found, loc }],
+                else_: null,
+                loc,
+            },
+        ];
     const visit = visitBody;
     const loop = last
         ? reverseArrayLoop(loc, visit)
@@ -1011,6 +1094,9 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
         locals: [
             ...arrayCallbackLocals(arrT, fnT),
             { id: "v.0", name: "v", type: valueT, mutable: false },
+            ...(ignored
+                ? slotSnapshotLocals(lowerer, elem, FILTER_SNAPSHOT).filter((l) => l.id !== "v.0")
+                : []),
         ],
         body,
         loc,
@@ -1034,9 +1120,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) {
+function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null, present = false, unread = false) {
     const method = last ? "findLastIndex" : "findIndex";
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1051,13 +1137,14 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
             outElem: elem,
             present,
             split: !!fastT,
+            unread,
         });
     const arrT = arrayOf(elem);
     const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
     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), 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)),
             then: [{ kind: "return", value: varRef("i.0", F64, loc), loc }],
             else_: null,
             loc,
@@ -1086,8 +1173,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) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
+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" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1101,10 +1188,11 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fa
         outElem: elem,
         present,
         split: !!fastT,
+        unread,
     });
     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), 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));
     const body = [
         arrayLengthDeclaration(arrT, loc),
         countedFor(loc, varRef("n.0", F64, loc), () => [
@@ -1152,7 +1240,11 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const present = presentElements(lowerer, call, elem);
-    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT);
+    const lowered = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT);
+    const { fnArg, arity } = lowered;
+    // Only an array that can hold elements outside its element type needs to
+    // leave an element its callback ignores unread.
+    const unread = lowered.unread && !present && elementMayBeForeign(lowerer, elem);
     const fnRet = fnArg.type.ret;
     if (fnRet.kind === "dyn" ||
         (fnRet.kind === "record" && lowerer.shapes.get(fnRet.shapeId)?.tuple)) {
@@ -1192,13 +1284,13 @@ 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
+        const fast = present || unread
             ? 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);
+        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
         return {
             kind: "call",
             callee: helper,
@@ -1207,13 +1299,13 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             loc,
         };
     }
-    const fast = present
+    const fast = present || unread
         ? 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);
+    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
     return {
         kind: "call",
         callee: helper,
@@ -1460,8 +1552,8 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
  *   }
  *   return out;
  */
-function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null, present = false) {
-    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
+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" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1475,6 +1567,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
         outElem: fnRet.elem,
         present,
         split: !!fastT,
+        unread,
     });
     const arrT = arrayOf(elem);
     const inner = fnRet.elem;
@@ -1545,7 +1638,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), loc),
+                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc),
                         loc,
                     },
                     {
@@ -1603,9 +1696,15 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
         (hasInit ? lowerer.irTypeOf(call) : arrayValueType(lowerer, elem));
     if (accT.kind === "void" || accT.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
-    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT, false, accT);
-    const fast = 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);
+    const lowered = lowerArrayCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT, false, accT);
+    const { fnArg, arity } = lowered;
+    // Only an array that can hold elements outside its element type needs to
+    // leave an element its callback ignores unread.
+    const unread = lowered.unread && elementMayBeForeign(lowerer, elem);
+    const fast = unread
+        ? 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 args = [receiver, fnArg];
     if (hasInit)
         args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], accT));
@@ -1625,8 +1724,8 @@ 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) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}`;
+function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, site = "", fastT = null, unread = false) {
+    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;
@@ -1642,6 +1741,7 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
             present: false,
             split: !!fastT,
             hasInit,
+            unread,
         });
     const arrT = arrayOf(elem);
     const fnT = funcOf([accT, arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
@@ -1649,6 +1749,9 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
     const i = varRef("i.0", F64, loc);
     const right = method === "reduceRight";
     const at = (index) => arrayValueRead(lowerer, varRef("a.0", arrT, loc), index, elem, loc);
+    // The visited element, or a placeholder for a callback that never reads it.
+    const placeholder = unread ? unreadArgument(lowerer, arrayValueType(lowerer, elem), loc) : null;
+    const visited = () => placeholder ?? at(i);
     const locals = [
         { id: "a.0", name: "a", type: arrT, mutable: true },
         { id: "f.0", name: "f", type: fnT, mutable: true },
@@ -1758,7 +1861,7 @@ 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), at(i), i, varRef("a.0", arrT, loc)].slice(0, arity),
+                            args: [varRef("acc.0", accT, loc), visited(), i, varRef("a.0", arrT, loc)].slice(0, arity),
                             type: fnRet,
                             loc,
                         }, accT),
@@ -1917,7 +2020,9 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
         helper = keyedHelperName(lowerer, `%arr.${method}`, key);
         lowerer.arrHofHelpers.set(key, helper);
         const undefinedTag = elem.kind === "union" ? lowerer.armTag(elem.unionId, UNDEFINED_T) : -1;
-        lowerer.liftedFns.push(buildArraySortFn(helper, elem, arity, copyFirst, undefinedTag >= 0 ? undefinedTag : null, loc, native, keyed && { order, key: reads !== null, keys: keyed.length }));
+        lowerer.liftedFns.push(buildArraySortFn(helper, elem, arity, copyFirst, undefinedTag >= 0 ? undefinedTag : null, loc, native, keyed && { order, key: reads !== null, keys: keyed.length }, elementMayBeForeign(lowerer, elem)
+            ? (arr, index) => foreignElementThrow(lowerer, arr, index, elem, loc)
+            : null));
     }
     const args = [receiver, fnArg];
     if (reads)
@@ -2534,4 +2639,42 @@ export function lowerTuplePredicateCall(lowerer, call, method, receiver, elem, r
         loc,
     };
 }
+/** The `%arr.<method>` helper `name` (map, flatMap or filter) taking its
+ * iteration bound as a last parameter: the loop runs to the bound instead
+ * of the receiver's length when it starts. ArraySpeciesCreate reads the
+ * receiver's length before the species constructor runs, so a constructor
+ * that appends to the receiver does not extend the loop
+ * (lowerWithArraySpecies). Every helper that reads a length is one, the
+ * flatMap whose callback returns a union included, whether or not a
+ * pipeline can fuse it (arrHofInfo holds the fusable ones); forEach makes
+ * no array, so it stays out. Null when `name` is no such helper. */
+export function boundedArrayHofHelper(lowerer, name) {
+    if (!name.startsWith("%arr."))
+        return null;
+    if (lowerer.arrHofInfo.get(name)?.method === "forEach")
+        return null;
+    const bounded = `${name}.bounded`;
+    if (lowerer.liftedFnNamed(bounded))
+        return bounded;
+    const fn = lowerer.liftedFnNamed(name);
+    if (!fn)
+        return null;
+    let replaced = false;
+    const body = fn.body.map((stmt) => {
+        if (replaced || stmt.kind !== "varDecl" || stmt.localId !== "n.0")
+            return stmt;
+        replaced = true;
+        return { ...stmt, init: varRef("bound.0", F64, stmt.loc) };
+    });
+    if (!replaced)
+        return null;
+    lowerer.liftedFns.push({
+        ...fn,
+        name: bounded,
+        params: [...fn.params, { localId: "bound.0", name: "bound", type: F64 }],
+        locals: [...fn.locals, { id: "bound.0", name: "bound", type: F64, mutable: false }],
+        body,
+    });
+    return bounded;
+}
 //# sourceMappingURL=array-callbacks.js.map