@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/lowering/containers/array-callbacks.d.ts

@@ -12,6 +12,13 @@ import { type IrExpr, type IrType } from "../../../ir/ir.js";
  * left-to-right and receive whatever prefix of (element, index, array)
  * they declare. */
 export declare function lowerArrayHofCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, method: "map" | "filter" | "forEach", elem: IrType): IrExpr;
+/** The interning suffix for a callback argument. A literal closure (an
+ * inline arrow or function expression) gets a helper of its own, so the
+ * helper's only incoming callback is one known function: the backend's
+ * constant-callback census then calls it directly and LLVM can inline the
+ * callback into the loop (TurboFan's builtin+callback inlining). Callback
+ * values keep the shared, type-interned helper. */
+export declare function callbackSite(fnArg: IrExpr): string;
 /** 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

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

@@ -1,3 +1,4 @@
+import { keyedHelperName } from "../stable-names.js";
 import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js";
 import { transformStmtList } from "../../../ir/traverse.js";
 import { InternalCompilerError } from "../../../errors.js";
@@ -13,6 +14,7 @@ import { lowerArrayCallback, requireProducedArrayElement, callbackArrayElement,
 import { reverseArrayLoop, arrayLengthDeclaration, arrayCallbackParams, arrayCallbackLocals, callArrayCallback, } from "./array-iteration.js";
 import { dynamicReceiverThrows } from "./dynamic-receivers.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "../optional-arguments.js";
+import { checkedFilterNarrowing } from "./filter-predicates.js";
 /** `a.map(fn)` / `a.filter(fn)` / `a.forEach(fn)` desugar to a direct
  * call of a synthetic module function — one per method + element/result
  * type + callback-arity combination, interned — whose body is a plain
@@ -68,28 +70,65 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         }
         lowerer.badType(argNode, lowerer.typeOf(argNode));
     }
-    const outElem = method === "filter"
+    const filtered = method === "filter"
         ? filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter)
-        : callbackArrayElement(lowerer, call, fnRet);
+        : 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))
         ? 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 resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
-    return {
+    const result = {
         kind: "call",
         callee: helper,
         args: [receiver, fnArg, ...(fast ? [fast] : [])],
         type: resultType,
         loc,
     };
+    const narrowing = filtered?.narrowing ?? null;
+    if (narrowing === null)
+        return result;
+    return {
+        kind: "call",
+        callee: narrowing.helper,
+        args: [result],
+        type: arrayOf(narrowing.elem),
+        loc,
+    };
 }
-/** The checker-selected element of a filter result, with the same trust
- * boundary as the historical narrowing filter: an inferred inline type
- * predicate may prove one source arm; a written predicate annotation may
- * not. Boolean is safe when every discarded arm is a nullish unit. */
+/** 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
+ * view, so the loop keeps that type directly. A written predicate (`(p): p
+ * is Cat => ...`, a guard function passed as a value) is an assertion
+ * TypeScript does not check, and an inferred predicate that keeps several
+ * arms has no single arm to re-tag: the loop keeps the receiver's element
+ * and `narrowing` (checkedFilterNarrowing) converts each kept element.
+ * Boolean is safe when every discarded arm is a nullish unit. */
 function filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
+    const kept = filterKeptElem(lowerer, call, argNode, elem, valueT, booleanFilter);
+    if (typeof kept !== "string")
+        return { elem: kept, narrowing: null };
+    return { elem, narrowing: { helper: kept, elem: filterCheckerElem(lowerer, call, elem) } };
+}
+/** The checker's spelling of a filter result's element type. */
+function filterTypeText(lowerer, call) {
+    const result = lowerer.typeOf(call);
+    const element = lowerer.checker.isArrayType(result)
+        ? lowerer.checker.getTypeArguments(result)[0]
+        : undefined;
+    return element === undefined ? "" : lowerer.checker.typeToString(element);
+}
+/** The checker's element of a filter result, or the receiver's when the
+ * filter introduces no refinement. */
+function filterCheckerElem(lowerer, call, elem) {
+    const result = lowerer.mapTypeOf(lowerer.typeOf(call));
+    return result?.kind === "array" ? result.elem : elem;
+}
+/** filterResultElem's element, or the name of the checked narrowing helper. */
+function filterKeptElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
     const callT = lowerer.typeOf(call);
     const result = lowerer.mapTypeOf(callT);
     let outElem = result?.kind === "array" ? result.elem : elem;
@@ -113,19 +152,29 @@ function filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
     const annotateEscape = "keep the receiver's element type instead — annotate the callback's return ': boolean' " +
         "(the checker then skips the predicate) or annotate the result with the receiver's own " +
         "element type — and narrow the elements after";
-    if (!booleanFilter) {
+    const written = !booleanFilter &&
+        ((!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) ||
+            argNode.type !== undefined);
+    const narrowing = booleanFilter
+        ? null
+        : () => checkedFilterNarrowing(lowerer, elem, outElem, filterTypeText(lowerer, call), locOf(call));
+    if (written) {
+        const helper = narrowing();
+        if (helper !== null)
+            return helper;
         if (!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) {
-            lowerer.unsupported("SC1090", argNode, `narrowing '.filter' through a callback VALUE (only an inline callback whose predicate ` +
-                `the checker inferred can re-tag — ${annotateEscape})`);
-        }
-        if (argNode.type) {
-            lowerer.unsupported("SC1090", argNode, `narrowing '.filter' with a hand-written type predicate (a written 'x is T' is an ` +
-                `unchecked assertion nothing validates at runtime — ${annotateEscape})`);
+            lowerer.unsupported("SC1090", argNode, `narrowing '.filter' to '${lowerer.fmt(outElem)}' through a callback VALUE (no checked ` +
+                `conversion from '${lowerer.fmt(elem)}' — ${annotateEscape})`);
         }
+        lowerer.unsupported("SC1090", argNode, `narrowing '.filter' to '${lowerer.fmt(outElem)}' with a hand-written type predicate (no ` +
+            `checked conversion from '${lowerer.fmt(elem)}' — ${annotateEscape})`);
     }
     const classRefinement = !booleanFilter && outElem.kind === "object" && canAssertClassValue(lowerer, valueT, outElem);
     if (!classRefinement &&
         (valueT.kind !== "union" || lowerer.armTag(valueT.unionId, outElem) < 0)) {
+        const helper = narrowing?.() ?? null;
+        if (helper !== null)
+            return helper;
         const multiArm = outElem.kind === "union";
         lowerer.unsupported("SC1090", call, `'.filter' narrowing '${lowerer.fmt(elem)}' elements to ` +
             `${multiArm ? `the multi-arm '${lowerer.fmt(outElem)}'` : `'${lowerer.fmt(outElem)}'`} ` +
@@ -349,7 +398,7 @@ function withFastCallback(fn, fastT, elem) {
  * constant-callback census then calls it directly and LLVM can inline the
  * callback into the loop (TurboFan's builtin+callback inlining). Callback
  * values keep the shared, type-interned helper. */
-function callbackSite(fnArg) {
+export function callbackSite(fnArg) {
     return fnArg.kind === "closure" ? `@${fnArg.fnName}` : "";
 }
 /** The optional-read analysis proved this call's receiver never holds an
@@ -381,7 +430,7 @@ function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRe
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+    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);
@@ -464,7 +513,7 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.union.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, "%arr.union", key);
     lowerer.arrHofHelpers.set(key, name);
     const receiver = varRef("a.0", receiverT, loc);
     const callback = varRef("f.0", callbackT, loc);
@@ -590,6 +639,10 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
                 loc,
             },
             readLen,
+            // map's result has the receiver's length, holes where the receiver
+            // has them. Storage for it is reserved first and the length is set
+            // after the loop, so a result without holes is filled by appends and
+            // gets no state bytes.
             ...(method === "map"
                 ? [
                     {
@@ -597,6 +650,7 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
                         arr: varRef("out.0", outT, loc),
                         length: varRef("n.0", F64, loc),
                         loc,
+                        reserve: true,
                     },
                 ]
                 : []),
@@ -621,6 +675,16 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
                     loc,
                 },
             ]),
+            ...(method === "map"
+                ? [
+                    {
+                        kind: "arraySetLength",
+                        arr: varRef("out.0", outT, loc),
+                        length: varRef("n.0", F64, loc),
+                        loc,
+                    },
+                ]
+                : []),
             { kind: "return", value: varRef("out.0", outT, loc), loc },
         ];
     }
@@ -900,7 +964,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
     const valueT = callbackValueType(lowerer, elem, present);
@@ -975,7 +1039,7 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
     if (!last)
         lowerer.arrHofInfo.set(name, {
@@ -1026,7 +1090,7 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fa
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
     lowerer.arrHofInfo.set(name, {
         method,
@@ -1103,6 +1167,19 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     }
     if (fnRet.kind === "union") {
         const def = lowerer.unions.get(fnRet.unionId);
+        const plan = def?.arms.some((a) => a.kind === "array")
+            ? flatMapUnionPlan(lowerer, call, argNode, fnRet)
+            : null;
+        if (plan) {
+            const helper = flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present);
+            return {
+                kind: "call",
+                callee: helper,
+                args: [receiver, fnArg],
+                type: arrayOf(plan.outElem),
+                loc,
+            };
+        }
         if (def?.arms.some((a) => a.kind === "array")) {
             lowerer.unsupported("SC1090", argNode, "'.flatMap' callbacks returning a union with an array arm (whether one value flattens " +
                 "would be a per-element decision — return an array from every path instead)");
@@ -1144,6 +1221,232 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
         loc,
     };
 }
+/** The plan for a callback returning `T | U[]`: every non-array arm must
+ * convert into the result's element type without a check, and every
+ * array arm's element type must be the result's. Null when an arm does
+ * not. */
+function flatMapUnionPlan(lowerer, call, argNode, fnRet) {
+    const out = lowerer.mapTypeOf(lowerer.typeOf(call));
+    if (out?.kind !== "array")
+        return null;
+    const outElem = out.elem;
+    const arms = lowerer.unions.get(fnRet.unionId)?.arms;
+    if (!arms)
+        return null;
+    // The `never[]` constituents of the callback's checked result.
+    const emptyArms = [];
+    const signature = lowerer.checker.getCallSignatures(lowerer.typeOf(argNode))[0];
+    if (signature) {
+        const ret = lowerer.checker.getReturnTypeOfSignature(signature);
+        for (const part of ret.isUnionType() ? ts.constituentTypes(ret) : [ret]) {
+            if (!lowerer.checker.isArrayType(part))
+                continue;
+            const [element] = lowerer.checker.getTypeArguments(part);
+            if (element === undefined || (element.flags & ts.TypeFlags.Never) === 0)
+                continue;
+            const mapped = lowerer.mapTypeOf(part);
+            if (mapped)
+                emptyArms.push(mapped);
+        }
+    }
+    const converts = (t) => {
+        if (typeEquals(t, outElem))
+            return true;
+        if (outElem.kind !== "union")
+            return false;
+        return lowerer.armTag(outElem.unionId, t) >= 0;
+    };
+    const plan = [];
+    for (const arm of arms) {
+        if (arm.kind === "array" && emptyArms.some((e) => typeEquals(e, arm)))
+            plan.push("empty");
+        // An array arm copies its elements as they are stored, a present
+        // undefined included, so its element type is the result's.
+        else if (arm.kind === "array" && typeEquals(arm.elem, outElem))
+            plan.push("spread");
+        else if (arm.kind !== "array" && converts(arm))
+            plan.push("value");
+        else
+            return null;
+    }
+    return { outElem, arms: plan };
+}
+/** 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) {
+    // 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 existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%arr.flatMap.${lowerer.arrHofHelpers.size}`;
+    lowerer.arrHofHelpers.set(key, name);
+    const arrT = arrayOf(elem);
+    const outT = arrayOf(plan.outElem);
+    const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
+    const arms = lowerer.unions.get(fnRet.unionId).arms;
+    const outRef = () => varRef("out.0", outT, loc);
+    const resultRef = () => varRef("r.0", fnRet, loc);
+    const outLength = () => ({
+        kind: "arrIntrinsic",
+        method: "length",
+        receiver: outRef(),
+        args: [],
+        type: F64,
+        loc,
+    });
+    const locals = [
+        ...arrayCallbackLocals(arrT, fnT),
+        { id: "out.0", name: "out", type: outT, mutable: false },
+        { id: "r.0", name: "r", type: fnRet, mutable: false },
+    ];
+    const armBody = (tag) => {
+        const arm = arms[tag];
+        const narrowed = {
+            kind: "unionNarrow",
+            unionId: fnRet.unionId,
+            tag,
+            value: resultRef(),
+            type: arm,
+            loc,
+        };
+        if (plan.arms[tag] === "empty")
+            return [];
+        if (plan.arms[tag] === "value") {
+            return [
+                arrayValueStore(lowerer, outRef(), outLength(), lowerer.coerceToExpected(
+                // A unit arm's value is the unit itself, which has no
+                // narrowed representation.
+                isUnitType(arm)
+                    ? {
+                        kind: "unitLit",
+                        unit: arm.kind === "nullT" ? "null" : "undefined",
+                        type: arm,
+                        loc,
+                    }
+                    : narrowed, plan.outElem), plan.outElem, loc),
+            ];
+        }
+        const innerT = arm;
+        const listId = `list.${tag}`;
+        const lengthId = `m.${tag}`;
+        const indexId = `j.${tag}`;
+        const itemId = `inner.${tag}`;
+        locals.push({ id: listId, name: "list", type: innerT, mutable: false }, { id: lengthId, name: "m", type: F64, mutable: false }, { id: indexId, name: "j", type: F64, mutable: true }, { id: itemId, name: "inner", type: arrayValueType(lowerer, innerT.elem), mutable: false });
+        const list = () => varRef(listId, innerT, loc);
+        const index = () => varRef(indexId, F64, loc);
+        return [
+            { kind: "varDecl", localId: listId, init: narrowed, loc },
+            {
+                kind: "varDecl",
+                localId: lengthId,
+                init: {
+                    kind: "arrIntrinsic",
+                    method: "length",
+                    receiver: list(),
+                    args: [],
+                    type: F64,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "for",
+                init: { kind: "varDecl", localId: indexId, init: numLit(0, loc), loc },
+                cond: {
+                    kind: "bin",
+                    op: "<",
+                    left: index(),
+                    right: varRef(lengthId, F64, loc),
+                    type: BOOL,
+                    loc,
+                },
+                update: {
+                    kind: "assign",
+                    localId: indexId,
+                    value: { kind: "bin", op: "+", left: index(), right: numLit(1, loc), type: F64, loc },
+                    loc,
+                },
+                body: [
+                    {
+                        kind: "if",
+                        cond: arrayIndexPresent(list(), index(), loc),
+                        then: [
+                            {
+                                kind: "varDecl",
+                                localId: itemId,
+                                init: arrayValueRead(lowerer, list(), index(), innerT.elem, loc),
+                                loc,
+                            },
+                            arrayValueStore(lowerer, outRef(), outLength(), varRef(itemId, arrayValueType(lowerer, innerT.elem), loc), plan.outElem, loc),
+                        ],
+                        else_: null,
+                        loc,
+                    },
+                ],
+                loc,
+            },
+        ];
+    };
+    let dispatch = armBody(arms.length - 1);
+    for (let tag = arms.length - 2; tag >= 0; tag--) {
+        dispatch = [
+            {
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: fnRet.unionId,
+                    tag,
+                    value: resultRef(),
+                    negated: false,
+                    type: BOOL,
+                    loc,
+                },
+                then: armBody(tag),
+                else_: dispatch,
+                loc,
+            },
+        ];
+    }
+    const body = [
+        {
+            kind: "varDecl",
+            localId: "out.0",
+            init: { kind: "arrayLit", elems: [], type: outT, loc },
+            loc,
+        },
+        arrayLengthDeclaration(arrT, loc),
+        countedFor(loc, varRef("n.0", F64, loc), () => [
+            {
+                kind: "if",
+                cond: currentArrayIndexPresent(arrT, loc),
+                then: [
+                    {
+                        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),
+                        loc,
+                    },
+                    ...dispatch,
+                ],
+                else_: null,
+                loc,
+            },
+        ]),
+        { kind: "return", value: outRef(), loc },
+    ];
+    lowerer.liftedFns.push({
+        name,
+        params: arrayCallbackParams(arrT, fnT),
+        returnType: outT,
+        locals,
+        body,
+        loc,
+    });
+    return name;
+}
 /** The flatMap loop (array-returning callback), from existing IR nodes:
  *
  *   out = []; n = a.length;
@@ -1158,7 +1461,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.flatMap.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, "%arr.flatMap", key);
     lowerer.arrHofHelpers.set(key, name);
     lowerer.arrHofInfo.set(name, {
         method: "flatMapArray",
@@ -1323,7 +1626,7 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
     if (method === "reduce")
         lowerer.arrHofInfo.set(name, {
@@ -1574,7 +1877,7 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
     const key = `${method}:${typeKey(elem)}:${arity}${native ? ":native" : ""}${keyed ? `:keyed${order}${reads ? `:field${reads.length}` : ""}` : ""}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+        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 }));
@@ -1601,7 +1904,7 @@ function sortKeyReader(lowerer, elem, reads, loc) {
     const cacheKey = `sortKey:${typeKey(elem)}:${sortKeysId(reads.map((read) => ({ order: 1, read })))}`;
     let reader = lowerer.arrHofHelpers.get(cacheKey);
     if (!reader) {
-        reader = `%arr.sortKey.${lowerer.arrHofHelpers.size}`;
+        reader = keyedHelperName(lowerer, "%arr.sortKey", cacheKey);
         lowerer.arrHofHelpers.set(cacheKey, reader);
         lowerer.liftedFns.push(buildSortKeyFn(reader, elem, reads, loc));
     }
@@ -1731,7 +2034,7 @@ function dynFlatMapHelper(lowerer, elemT, arity, loc) {
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%dyn.flatmap.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, "%dyn.flatmap", key);
     lowerer.arrHofHelpers.set(key, name);
     lowerer.liftedFns.push(buildDynFlatMapFn(name, elemT, arity, loc));
     return name;
@@ -1897,7 +2200,7 @@ function dynFilterHelper(lowerer, elemT, arity, loc) {
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%dyn.filter.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, "%dyn.filter", key);
     lowerer.arrHofHelpers.set(key, name);
     lowerer.liftedFns.push(buildDynFilterFn(name, elemT, arity, loc));
     return name;
@@ -2046,6 +2349,7 @@ export function lowerTuplePredicateCall(lowerer, call, method, receiver, elem, r
     // the value type an array find narrows from.
     let foundT = elem;
     let retag = null;
+    let narrowing = null;
     if (method === "filter") {
         // The element union is built in position order, so the checker's
         // result element can list the same arms in another order.
@@ -2054,9 +2358,11 @@ export function lowerTuplePredicateCall(lowerer, call, method, receiver, elem, r
         const unchanged = checkerResult?.kind === "array" &&
             arms(checkerResult.elem).length === arms(elem).length &&
             arms(checkerResult.elem).every((arm) => arms(elem).some((other) => typeEquals(arm, other)));
-        outElem = unchanged
-            ? elem
-            : filterResultElem(lowerer, call, argNode, elem, elem, booleanFilter);
+        if (!unchanged) {
+            const filtered = filterResultElem(lowerer, call, argNode, elem, elem, booleanFilter);
+            outElem = filtered.elem;
+            narrowing = filtered.narrowing;
+        }
         resultT = arrayOf(outElem);
     }
     else if (method === "find") {
@@ -2074,7 +2380,7 @@ export function lowerTuplePredicateCall(lowerer, call, method, receiver, elem, r
     const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(resultT)}:${arity}${callbackSite(fnArg)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`;
+        helper = keyedHelperName(lowerer, `%tuple.${method}`, key);
         lowerer.arrHofHelpers.set(key, helper);
         const v = varRef("v.0", elem, loc);
         const out = varRef("out.0", resultT, loc);
@@ -2174,6 +2480,21 @@ export function lowerTuplePredicateCall(lowerer, call, method, receiver, elem, r
             loc,
         });
     }
-    return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
+    const result = {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg],
+        type: resultT,
+        loc,
+    };
+    if (narrowing === null)
+        return result;
+    return {
+        kind: "call",
+        callee: narrowing.helper,
+        args: [result],
+        type: arrayOf(narrowing.elem),
+        loc,
+    };
 }
 //# sourceMappingURL=array-callbacks.js.map