@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -6,10 +6,10 @@ import * as ts from "../../ts7/adapter.js";
 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, } from "../lower-array-sort.js";
+import { buildArraySortFn, buildSortKeyFn, closureKeyOrder, sortKeysId, sortKeysOrder, } from "../lower-array-sort.js";
 import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent, } from "../array-values.js";
 import { typeKey } from "../../type-mapper.js";
-import { lowerArrayCallback, requireProducedArrayElement, callbackArrayElement, } from "./callback-arguments.js";
+import { lowerArrayCallback, requireProducedArrayElement, callbackArrayElement, truthyFilterCallback, } from "./callback-arguments.js";
 import { reverseArrayLoop, arrayLengthDeclaration, arrayCallbackParams, arrayCallbackLocals, callArrayCallback, } from "./array-iteration.js";
 import { dynamicReceiverThrows } from "./dynamic-receivers.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "../optional-arguments.js";
@@ -26,7 +26,7 @@ import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "../opti
 export function lowerArrayHofCall(lowerer, call, access, method, elem) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const booleanFilter = method === "filter" &&
@@ -38,7 +38,9 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
     if (booleanFilter) {
         if (valueT.kind === "union")
             lowerer.requireTruthyUnion(valueT.unionId, argNode);
-        if (valueT.kind === "dyn" || valueT.kind === "void" || isUnitType(valueT)) {
+        // Checked-dynamic elements (`anyText.split("\n").map(...).filter(Boolean)`)
+        // keep their runtime kind, so their truthiness is the runtime's.
+        if (valueT.kind === "void" || isUnitType(valueT)) {
             lowerer.badType(argNode, lowerer.typeOf(argNode));
         }
     }
@@ -138,28 +140,6 @@ function filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
     }
     return outElem;
 }
-/** A native closure for the ambient Boolean callback. Reifying the
- * JavaScript constructor itself is unnecessary; Array#filter only observes
- * its one-argument ToBoolean result. */
-function truthyFilterCallback(lowerer, valueT, loc) {
-    const fnT = { kind: "func", params: [valueT], ret: BOOL };
-    const key = `filterBoolean:${typeKey(valueT)}`;
-    let name = lowerer.arrHofHelpers.get(key);
-    if (!name) {
-        name = `%arr.filterBoolean.${lowerer.arrHofHelpers.size}`;
-        lowerer.arrHofHelpers.set(key, name);
-        const value = varRef("v.0", valueT, loc);
-        lowerer.liftedFns.push({
-            name,
-            params: [{ localId: "v.0", name: "v", type: valueT }],
-            returnType: BOOL,
-            locals: [{ id: "v.0", name: "v", type: valueT, mutable: false }],
-            body: [{ kind: "return", value: { kind: "toBool", operand: value, type: BOOL, loc }, loc }],
-            loc,
-        });
-    }
-    return { kind: "closure", fnName: name, captures: [], type: fnT, loc };
-}
 function filterPredicateOk(lowerer, ret) {
     if (ret.kind === "bool")
         return true;
@@ -218,7 +198,7 @@ function lowerFastCallback(lowerer, argNode, lead, elemIndex, elem, arrT, slow,
     if (fastLoweringDepth > 0 ||
         slow.arity <= elemIndex ||
         !ts.isArrowFunction(argNode) ||
-        isJsSourceFile(argNode.getSourceFile()) ||
+        isJsSourceFile(ts.getSourceFileOfNode(argNode)) ||
         valueT?.kind !== "union" ||
         typeEquals(valueT, elem) ||
         elem.kind === "union" ||
@@ -230,7 +210,7 @@ function lowerFastCallback(lowerer, argNode, lead, elemIndex, elem, arrT, slow,
     // The optional-read prepass binds an unannotated element parameter to
     // the array's runtime value type. Rebind it to the plain element for
     // this lowering only.
-    const param = argNode.parameters[elemIndex];
+    const param = argNode.parameters.nodes[elemIndex];
     if (!param || param.initializer || param.dotDotDotToken || !ts.isIdentifier(param.name))
         return null;
     const symbol = param.type ? undefined : lowerer.checker.getSymbolAtLocation(param.name);
@@ -423,7 +403,7 @@ export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
     const def = lowerer.unions.get(receiverT.unionId);
     if (!def || def.arms.length < 2 || !def.arms.every((arm) => arm.kind === "array"))
         return null;
-    if (call.arguments.length !== 1 || !call.arguments[0])
+    if (call.arguments.nodes.length !== 1 || !call.arguments.nodes[0])
         return null;
     const arrays = def.arms;
     const valueArms = [];
@@ -451,7 +431,7 @@ export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
     const valueT = valueArms.length === 1
         ? valueArms[0]
         : { kind: "union", unionId: lowerer.unions.intern(valueArms) };
-    const argNode = call.arguments[0];
+    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")) {
@@ -549,6 +529,25 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
     });
     return name;
 }
+/** A kept filter element as the result's element type: the value itself,
+ * or its narrowed arm or class view when the predicate narrowed it. */
+function filterRetainedValue(lowerer, v, elem, outElem, loc) {
+    if (typeEquals(outElem, elem))
+        return v;
+    const classView = outElem.kind === "object" ? checkedClassAssertion(lowerer, v, outElem, loc) : null;
+    if (classView !== null)
+        return classView;
+    if (v.type.kind !== "union")
+        return v;
+    return {
+        kind: "unionNarrow",
+        unionId: v.type.unionId,
+        tag: lowerer.armTag(v.type.unionId, outElem),
+        value: v,
+        type: outElem,
+        loc,
+    };
+}
 /** The loop body of one synthetic array HOF, from existing IR nodes:
  *
  *   map:     out = []; n = a.length; for (i = 0; i < n; i++) out.push(f(a[i])); return out;
@@ -713,23 +712,7 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
         const outT = arrayOf(outElem);
         locals.push({ id: "out.0", name: "out", type: outT, mutable: false }, { id: "v.0", name: "v", type: valueT, mutable: false });
         returnType = outT;
-        const classView = !typeEquals(outElem, elem) && outElem.kind === "object"
-            ? checkedClassAssertion(lowerer, varRef("v.0", valueT, loc), outElem, loc)
-            : null;
-        const retained = typeEquals(outElem, elem)
-            ? varRef("v.0", valueT, loc)
-            : classView !== null
-                ? classView
-                : valueT.kind === "union"
-                    ? {
-                        kind: "unionNarrow",
-                        unionId: valueT.unionId,
-                        tag: lowerer.armTag(valueT.unionId, outElem),
-                        value: varRef("v.0", valueT, loc),
-                        type: outElem,
-                        loc,
-                    }
-                    : varRef("v.0", valueT, loc);
+        const retained = filterRetainedValue(lowerer, varRef("v.0", valueT, loc), elem, outElem, loc);
         body = [
             {
                 kind: "varDecl",
@@ -802,7 +785,7 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
     const arrT = arrayOf(elem);
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     // find's result must be reachable from the element itself; a predicate
@@ -817,13 +800,7 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     // `packages.some((p) => p.scripts[name])` idiom, whose callback
     // returns the index read's `string | undefined`).
     const fnRet = fnArg.type.ret;
-    const truthyRet = fnRet.kind === "bool" ||
-        fnRet.kind === "f64" ||
-        fnRet.kind === "string" ||
-        fnRet.kind === "dyn" ||
-        (fnRet.kind === "union" &&
-            (lowerer.unions.get(fnRet.unionId)?.arms ?? []).every((a) => a.kind !== "dyn" && a.kind !== "caught"));
-    if (!truthyRet)
+    if (!findPredicateOk(lowerer, fnRet))
         lowerer.badType(argNode, lowerer.typeOf(argNode));
     const last = method === "findLast" || method === "findLastIndex";
     if (method === "some" ||
@@ -861,33 +838,50 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     const undefTag = lowerer.armTag(resultT.unionId, UNDEFINED_T);
     if (undefTag < 0)
         lowerer.badType(call, lowerer.typeOf(call));
-    let retag = null;
-    if (!lowerer.coercibleValue(valueT, resultT)) {
-        const inline = ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode);
-        if (!unchangedElement && (!inline || argNode.type !== undefined)) {
-            lowerer.unsupported("SC1090", argNode, `narrowing '.${method}' requires an inline callback with an inferred predicate (annotate the return ': boolean' to keep the receiver's element type)`);
-        }
-        const signature = inline ? lowerer.checker.getSignatureFromDeclaration(argNode) : undefined;
-        const predicate = signature
-            ? lowerer.checker.getTypePredicateOfSignature(signature)
-            : undefined;
-        if ((!unchangedElement && (!predicate || predicate.parameterIndex !== 0)) ||
-            valueT.kind !== "union") {
-            lowerer.unsupported("SC1090", call, `'.${method}' result narrowing without a predicate over its element`);
-        }
-        retag = lowerer.narrowedRetagHelper(call, valueT.unionId, resultT.unionId, loc);
-        const present = lowerer.stripUndefinedArm(resultT);
-        if (retag === null &&
-            !(present.kind === "object" && canAssertClassValue(lowerer, valueT, present)))
-            lowerer.unsupported("SC1090", call, `'.${method}' narrowing to an incompatible result layout`);
-    }
+    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);
     return { kind: "call", callee: helper, args: [receiver, fnArg], 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
+ * an inferred predicate over its element can narrow the result; a written
+ * predicate is an unchecked assertion and keeps the refusal. */
+function findResultRetag(lowerer, call, argNode, method, valueT, resultT, unchangedElement) {
+    if (lowerer.coercibleValue(valueT, resultT))
+        return null;
+    const loc = locOf(call);
+    const inline = ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode);
+    if (!unchangedElement && (!inline || argNode.type !== undefined)) {
+        lowerer.unsupported("SC1090", argNode, `narrowing '.${method}' requires an inline callback with an inferred predicate (annotate the return ': boolean' to keep the receiver's element type)`);
+    }
+    const signature = inline ? lowerer.checker.getSignatureFromDeclaration(argNode) : undefined;
+    const predicate = signature ? lowerer.checker.getTypePredicateOfSignature(signature) : undefined;
+    if ((!unchangedElement && (!predicate || predicate.parameterIndex !== 0)) ||
+        valueT.kind !== "union") {
+        lowerer.unsupported("SC1090", call, `'.${method}' result narrowing without a predicate over its element`);
+    }
+    const retag = lowerer.narrowedRetagHelper(call, valueT.unionId, resultT.unionId, loc);
+    const present = lowerer.stripUndefinedArm(resultT);
+    if (retag === null &&
+        !(present.kind === "object" && canAssertClassValue(lowerer, valueT, present)))
+        lowerer.unsupported("SC1090", call, `'.${method}' narrowing to an incompatible result layout`);
+    return retag;
+}
+/** The find-like predicate results whose ToBoolean has a static answer:
+ * bool passes through; f64/string by value; checked values and
+ * truthy-answerable unions by their runtime kind or arm. */
+export function findPredicateOk(lowerer, fnRet) {
+    return (fnRet.kind === "bool" ||
+        fnRet.kind === "f64" ||
+        fnRet.kind === "string" ||
+        fnRet.kind === "dyn" ||
+        (fnRet.kind === "union" &&
+            (lowerer.unions.get(fnRet.unionId)?.arms ?? []).every((a) => a.kind !== "dyn" && a.kind !== "caught")));
+}
 /** ToBoolean of a predicate result inside a synthesized HOF helper — the
  * ensureBool subset the find-like path admits (bool through; checked
  * values via dynTest; f64/string/truthy-answerable unions via toBool). */
-function predicateToBoolean(e) {
+export function predicateToBoolean(e) {
     if (e.type.kind === "bool")
         return e;
     if (e.type.kind === "dyn")
@@ -912,15 +906,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
     const valueT = callbackValueType(lowerer, elem, present);
     const fnT = funcOf([valueT, F64, arrT].slice(0, arity), fnRet);
     const v = varRef("v.0", valueT, loc);
-    const presentArm = lowerer.stripUndefinedArm(resultT);
-    // A successful inferred class predicate may select a descendant of a
-    // stored base arm. Keep the value read before the callback mutated the array.
-    const classView = retag === null && !lowerer.coercibleValue(valueT, resultT) && presentArm.kind === "object"
-        ? checkedClassAssertion(lowerer, v, presentArm, loc)
-        : null;
-    const found = retag === null
-        ? lowerer.coerceToExpected(classView ?? v, resultT)
-        : { kind: "call", callee: retag, args: [v], type: resultT, loc };
+    const found = findFoundValue(lowerer, v, resultT, retag, loc);
     const miss = {
         kind: "unionWrap",
         unionId: resultT.unionId,
@@ -966,6 +952,18 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
     });
     return name;
 }
+/** A found element as find's result union. A successful inferred class
+ * predicate may select a descendant of a stored base arm. The value is the
+ * one read before the callback ran, even if the callback mutated its slot. */
+function findFoundValue(lowerer, v, resultT, retag, loc) {
+    if (retag !== null)
+        return { kind: "call", callee: retag, args: [v], type: resultT, loc };
+    const presentArm = lowerer.stripUndefinedArm(resultT);
+    const classView = !lowerer.coercibleValue(v.type, resultT) && presentArm.kind === "object"
+        ? checkedClassAssertion(lowerer, v, presentArm, loc)
+        : null;
+    return lowerer.coerceToExpected(classView ?? v, resultT);
+}
 /** The findIndex/findLastIndex loop — find's index-returning sibling, no
  * union; findLastIndex is the identical loop walked backwards:
  *
@@ -1085,7 +1083,7 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
     const arrT = arrayOf(elem);
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const present = presentElements(lowerer, call, elem);
@@ -1097,7 +1095,7 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             kind: "dynInvoke",
             recv: { kind: "dynFrom", value: receiver, liveRef: true, type: DYN, loc },
             method: "flatMap",
-            calleeName: access.getText(),
+            calleeName: ts.getTextOfNode(access),
             args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }],
             type: DYN,
             loc,
@@ -1290,10 +1288,10 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
     const arrT = arrayOf(elem);
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const hasInit = call.arguments.length === 2;
+    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")
@@ -1303,7 +1301,7 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
     const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc, callbackSite(fast ?? fnArg), fast?.type ?? null);
     const args = [receiver, fnArg];
     if (hasInit)
-        args.push(lowerer.lowerExprExpecting(call.arguments[1], accT));
+        args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], accT));
     // The fast closure is created last; making a closure has no observable
     // effect, so the initial value still evaluates right after the callback.
     if (fast)
@@ -1494,7 +1492,7 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
     const loc = locOf(call);
     const method = access.name.text === "toSorted" ? "toSorted" : "sort";
     const copyFirst = method === "toSorted";
-    if (call.arguments.length === 0 &&
+    if (call.arguments.nodes.length === 0 &&
         (elem.kind === "string" || elem.kind === "f64" || elem.kind === "bool")) {
         return {
             kind: "arrIntrinsic",
@@ -1505,11 +1503,11 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
             loc,
         };
     }
-    if (call.arguments.length !== 1) {
-        lowerer.noLowering(`.${method} with ${call.arguments.length} arguments`, call, "default ordering supports string[], number[] and boolean[]; other element types need a comparator");
+    if (call.arguments.nodes.length !== 1) {
+        lowerer.noLowering(`.${method} with ${call.arguments.nodes.length} arguments`, call, "default ordering supports string[], number[] and boolean[]; other element types need a comparator");
     }
     const receiver = lowerer.lowerExpr(access.expression);
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, argNode);
     let unwrappedArg = argNode;
     while (ts.isParenthesizedExpression(unwrappedArg) ||
@@ -1550,7 +1548,7 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
         fnArg.type.params.every((param) => lowerer.coercibleValue(elem, param))) {
         // Arithmetic on inferred JS values retains a checked result because
         // it can produce BigInt. The sort callback still requires a number.
-        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(argNode.getSourceFile())
+        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(argNode))
             ? F64
             : fnArg.type.ret;
         const expected = funcOf(fnArg.type.params.map(() => elem), result);
@@ -1570,42 +1568,45 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
     // The runtime sorts raw slots without per-move reference counting; this
     // beats the IR merge sort even when its comparator call becomes direct.
     const native = isSortValuesElement(elem, elem.kind === "union" ? lowerer.unions.get(elem.unionId)?.arms : undefined);
-    const keyed = native ? recognizedSortKey(lowerer, fnArg, elem) : null;
-    const key = `${method}:${typeKey(elem)}:${arity}${native ? ":native" : ""}${keyed ? `:keyed${keyed.order}${keyed.read ? ":field" : ""}` : ""}`;
+    const keyed = native ? recognizedSortKeys(lowerer, fnArg, elem) : null;
+    const reads = keyed?.every((k) => k.read !== null) ? keyed.map((k) => k.read) : null;
+    const order = keyed ? sortKeysOrder(keyed) : 0;
+    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}`;
         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: keyed.order, key: keyed.read !== null }));
+        lowerer.liftedFns.push(buildArraySortFn(helper, elem, arity, copyFirst, undefinedTag >= 0 ? undefinedTag : null, loc, native, keyed && { order, key: reads !== null, keys: keyed.length }));
     }
     const args = [receiver, fnArg];
-    if (keyed?.read)
-        args.push(sortKeyReader(lowerer, elem, keyed.read, loc));
+    if (reads)
+        args.push(sortKeyReader(lowerer, elem, reads, loc));
     return { kind: "call", callee: helper, args, type: arrT, loc };
 }
-/** The key order of a capture-free comparator closure the runtime can sort
- * by without calling it: over number elements, or over one number field
- * of record or class elements. */
-function recognizedSortKey(lowerer, fnArg, elem) {
+/** The keys of a capture-free comparator closure the runtime can sort by
+ * without calling it: number elements themselves, or number fields of
+ * record or class elements (one or several). */
+function recognizedSortKeys(lowerer, fnArg, elem) {
     const keyed = closureKeyOrder(lowerer.liftedFns, fnArg);
     if (!keyed)
         return null;
-    if (keyed.read === null)
+    if (keyed[0].read === null)
         return elem.kind === "f64" ? keyed : null;
     return elem.kind === "record" || elem.kind === "object" ? keyed : null;
 }
-/** A zero-capture closure over the shared `(x) => x.field` key reader. */
-function sortKeyReader(lowerer, elem, read, loc) {
-    const owner = read.kind === "recordGet" ? read.shapeId : read.className;
-    const cacheKey = `sortKey:${typeKey(elem)}:${read.kind}:${owner}:${read.field}`;
+/** A zero-capture closure over the shared key reader of these reads
+ * (buildSortKeyFn): `(x) => x.field`, or `(x, j) => key j` for several. */
+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}`;
         lowerer.arrHofHelpers.set(cacheKey, reader);
-        lowerer.liftedFns.push(buildSortKeyFn(reader, elem, read, loc));
+        lowerer.liftedFns.push(buildSortKeyFn(reader, elem, reads, loc));
     }
-    return { kind: "closure", fnName: reader, captures: [], type: funcOf([elem], F64), loc };
+    const params = reads.length > 1 ? [elem, F64] : [elem];
+    return { kind: "closure", fnName: reader, captures: [], type: funcOf(params, F64), loc };
 }
 /** `d.filter(pred)` on a dyn receiver: the receiver must BE a dyn array
  * (else the Node-shaped TypeError above); the predicate runs per element
@@ -1618,9 +1619,9 @@ function sortKeyReader(lowerer, elem, read, loc) {
  * the dyn boundary's marshal-copy stance (SEMANTICS.md). Null when the
  * call shape isn't claimable (the method-call fence stays). */
 export function lowerDynArrayFilterCall(lowerer, call, access, recv) {
-    if (call.arguments.length !== 1)
+    if (call.arguments.nodes.length !== 1)
         return null;
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     const loc = locOf(call);
     // The result element type, from what the call flows INTO: the
     // contextual array (or the single array arm of a contextual union —
@@ -1664,7 +1665,7 @@ export function lowerDynArrayFilterCall(lowerer, call, access, recv) {
             recv,
             fnArg,
             { kind: "strLit", value: access.name.text, type: STRING, loc },
-            { kind: "strLit", value: access.getText(), type: STRING, loc },
+            { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc },
         ],
         type: arrayOf(elemT),
         loc,
@@ -1681,9 +1682,9 @@ export function lowerDynArrayFilterCall(lowerer, call, access, recv) {
  * NON-array values (JS would keep them as single elements) or dynamic
  * results keep the fence — nothing drives them yet. */
 export function lowerDynArrayFlatMapCall(lowerer, call, access, recv) {
-    if (call.arguments.length !== 1)
+    if (call.arguments.nodes.length !== 1)
         return null;
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     const loc = locOf(call);
     const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [DYN], DYN);
     const ret = fnArg.type.ret;
@@ -1700,7 +1701,7 @@ export function lowerDynArrayFlatMapCall(lowerer, call, access, recv) {
                 kind: "dynInvoke",
                 recv,
                 method: "flatMap",
-                calleeName: access.getText(),
+                calleeName: ts.getTextOfNode(access),
                 args: [boxed],
                 type: DYN,
                 loc,
@@ -1718,7 +1719,7 @@ export function lowerDynArrayFlatMapCall(lowerer, call, access, recv) {
             recv,
             fnArg,
             { kind: "strLit", value: access.name.text, type: STRING, loc },
-            { kind: "strLit", value: access.getText(), type: STRING, loc },
+            { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc },
         ],
         type: arrayOf(ret.elem),
         loc,
@@ -2007,4 +2008,172 @@ function buildDynFilterFn(name, elemT, arity, loc) {
         loc,
     };
 }
+/** Tuple `filter` / `find` / `findIndex` / `some` / `every`. `reads` holds
+ * one element read per position, in index order, each over the helper's
+ * `a.0` receiver parameter. The helper visits positions in order and reads
+ * each one only when it is visited, so a callback's write to a later
+ * position is visible; filter and find keep the value read before the
+ * callback ran. find, findIndex, some and every return at the first
+ * deciding position. Predicate results and narrowing follow the array
+ * methods' rules. */
+export function lowerTuplePredicateCall(lowerer, call, method, receiver, elem, reads) {
+    const loc = locOf(call);
+    const argNode = call.arguments.nodes[0];
+    const booleanFilter = method === "filter" &&
+        ts.isIdentifier(argNode) &&
+        argNode.text === "Boolean" &&
+        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode) ?? undefined);
+    if (booleanFilter) {
+        if (elem.kind === "union")
+            lowerer.requireTruthyUnion(elem.unionId, argNode);
+        if (elem.kind === "dyn" || elem.kind === "void" || isUnitType(elem)) {
+            lowerer.badType(argNode, lowerer.typeOf(argNode));
+        }
+    }
+    const { fnArg, arity } = booleanFilter
+        ? { fnArg: truthyFilterCallback(lowerer, elem, loc), arity: 1 }
+        : lowerArrayCallback(lowerer, argNode, [elem], receiver.type);
+    const fnRet = fnArg.type.ret;
+    if (method === "filter" ? !filterPredicateOk(lowerer, fnRet) : !findPredicateOk(lowerer, fnRet)) {
+        if (fnRet.kind === "void") {
+            lowerer.unsupported("SC1090", argNode, `'.${method}()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)`);
+        }
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    }
+    let resultT;
+    let outElem = elem;
+    // A narrowing find retags from the element union widened with undefined,
+    // the value type an array find narrows from.
+    let foundT = elem;
+    let retag = 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.
+        const checkerResult = lowerer.mapTypeOf(lowerer.typeOf(call));
+        const arms = (type) => type.kind === "union" ? lowerer.unions.get(type.unionId).arms : [type];
+        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);
+        resultT = arrayOf(outElem);
+    }
+    else if (method === "find") {
+        resultT = lowerer.irTypeOf(call);
+        if (resultT.kind !== "union" || lowerer.armTag(resultT.unionId, UNDEFINED_T) < 0) {
+            lowerer.badType(call, lowerer.typeOf(call));
+        }
+        if (!lowerer.coercibleValue(elem, resultT))
+            foundT = arrayValueType(lowerer, elem);
+        retag = findResultRetag(lowerer, call, argNode, method, foundT, resultT, false);
+    }
+    else {
+        resultT = method === "findIndex" ? F64 : BOOL;
+    }
+    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}`;
+        lowerer.arrHofHelpers.set(key, helper);
+        const v = varRef("v.0", elem, loc);
+        const out = varRef("out.0", resultT, loc);
+        const test = (index) => {
+            const invocation = {
+                kind: "callValue",
+                callee: varRef("f.0", fnArg.type, loc),
+                args: [v, numLit(index, loc)].slice(0, arity),
+                type: fnRet,
+                loc,
+            };
+            return method === "filter"
+                ? filterCond(invocation, fnRet, loc)
+                : predicateToBoolean(invocation);
+        };
+        const decided = (index) => {
+            switch (method) {
+                case "filter":
+                    return arrayValueStore(lowerer, out, { kind: "arrIntrinsic", method: "length", receiver: out, args: [], type: F64, loc }, filterRetainedValue(lowerer, v, elem, outElem, loc), outElem, loc);
+                case "find":
+                    return {
+                        kind: "return",
+                        value: findFoundValue(lowerer, lowerer.coerceToExpected(v, foundT), resultT, retag, loc),
+                        loc,
+                    };
+                case "findIndex":
+                    return { kind: "return", value: numLit(index, loc), loc };
+                case "some":
+                    return { kind: "return", value: boolLit(true, loc), loc };
+                case "every":
+                    return { kind: "return", value: boolLit(false, loc), loc };
+            }
+        };
+        const body = method === "filter"
+            ? [
+                {
+                    kind: "varDecl",
+                    localId: "out.0",
+                    init: { kind: "arrayLit", elems: [], type: resultT, loc },
+                    loc,
+                },
+            ]
+            : [];
+        reads.forEach((read, index) => {
+            body.push(index === 0
+                ? { kind: "varDecl", localId: "v.0", init: read, loc }
+                : { kind: "assign", localId: "v.0", value: read, loc }, {
+                kind: "if",
+                cond: method === "every"
+                    ? { kind: "unary", op: "!", operand: test(index), type: BOOL, loc }
+                    : test(index),
+                then: [decided(index)],
+                else_: null,
+                loc,
+            });
+        });
+        let done;
+        switch (method) {
+            case "filter":
+                done = out;
+                break;
+            case "find": {
+                const unionId = resultT.unionId;
+                done = {
+                    kind: "unionWrap",
+                    unionId,
+                    tag: lowerer.armTag(unionId, UNDEFINED_T),
+                    value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                    type: resultT,
+                    loc,
+                };
+                break;
+            }
+            case "findIndex":
+                done = numLit(-1, loc);
+                break;
+            default:
+                done = boolLit(method === "every", loc);
+        }
+        body.push({ kind: "return", value: done, loc });
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [
+                { localId: "a.0", name: "a", type: receiver.type },
+                { localId: "f.0", name: "f", type: fnArg.type },
+            ],
+            returnType: resultT,
+            locals: [
+                { id: "a.0", name: "a", type: receiver.type, mutable: false },
+                { id: "f.0", name: "f", type: fnArg.type, mutable: false },
+                ...(reads.length > 0 ? [{ id: "v.0", name: "v", type: elem, mutable: true }] : []),
+                ...(method === "filter"
+                    ? [{ id: "out.0", name: "out", type: resultT, mutable: false }]
+                    : []),
+            ],
+            body,
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
+}
 //# sourceMappingURL=array-callbacks.js.map