@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,3 +1,4 @@
+import { liftedFreshSpread } from "../coercions/fresh-spread.js";
 import { lowerArrayIteratorValue } from "../iterator-adapters.js";
 import { identityPreservingWidening } from "../coercions/identity.js";
 import { arrayConcatHelper } from "./array-concat.js";
@@ -14,7 +15,7 @@ import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, } f
 import { typeKey } from "../../type-mapper.js";
 import { defaultAfterUndefined, lowerPositionArgument, lowerStaticallyUndefinedArgument, positionNumber, } from "../optional-arguments.js";
 import { lowerArrayCopyWithin, lowerArrayFill } from "../array-indexed-mutation.js";
-import { lowerArrayUnionHofCall, lowerArraySortCall, lowerArrayHofCall, lowerArrayFindLikeCall, lowerArrayFlatMapCall, lowerArrayReduceCall, } from "./array-callbacks.js";
+import { lowerArrayUnionHofCall, lowerArraySortCall, lowerArrayHofCall, lowerArrayFindLikeCall, lowerArrayFlatMapCall, lowerArrayReduceCall, lowerTuplePredicateCall, } from "./array-callbacks.js";
 import { lowerArraySpreadItems, lowerArrayValueItems, widenArraySpread, } from "./array-construction.js";
 import { arrayLengthDeclaration } from "./array-iteration.js";
 import { lowerArrayCallback, callbackArrayElement, requireProducedArrayElement, } from "./callback-arguments.js";
@@ -247,7 +248,8 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
-    const iteratorMethod = (name === "values" || name === "keys" || name === "entries") && call.arguments.length === 0;
+    const iteratorMethod = (name === "values" || name === "keys" || name === "entries") &&
+        call.arguments.nodes.length === 0;
     if (!ARRAY_METHODS.has(name) &&
         name !== "sort" &&
         name !== "shift" &&
@@ -278,7 +280,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             // machinery answered string[]): same rule, any-typed spelling.
             ((lowerer.typeOf(access.expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !==
                 0 &&
-                isJsSourceFile(access.getSourceFile())))) {
+                isJsSourceFile(ts.getSourceFileOfNode(access))))) {
         const probe = lowerer.lowerExpr(access.expression);
         if (probe.type.kind === "array") {
             receiverIr = probe.type;
@@ -366,8 +368,8 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         return lowerArraySortCall(lowerer, call, access, elem, receiverIr);
     }
     if (name === "toReversed") {
-        if (call.arguments.length !== 0) {
-            lowerer.noLowering(`.toReversed with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length !== 0) {
+            lowerer.noLowering(`.toReversed with ${call.arguments.nodes.length} arguments`, call);
         }
         return {
             kind: "arrIntrinsic",
@@ -379,8 +381,8 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         };
     }
     if (name === "reverse") {
-        if (call.arguments.length !== 0) {
-            lowerer.noLowering(`.reverse with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length !== 0) {
+            lowerer.noLowering(`.reverse with ${call.arguments.nodes.length} arguments`, call);
         }
         return {
             kind: "arrIntrinsic",
@@ -392,43 +394,43 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         };
     }
     if (name === "fill") {
-        if (call.arguments.length > 3 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.fill with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length > 3 || call.arguments.nodes.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.fill with ${call.arguments.nodes.length} arguments`, call);
         }
-        const value = call.arguments[0] ? lowerer.lowerExpr(call.arguments[0]) : null;
+        const value = call.arguments.nodes[0] ? lowerer.lowerExpr(call.arguments.nodes[0]) : null;
         if (value &&
             value.type.kind === "dyn" &&
             isRefCounted(elem) &&
             elem.kind !== "string" &&
             !typeEquals(value.type, elem)) {
-            lowerer.noLowering(".fill of a checked-dynamic reference into a static array", call.arguments[0]);
+            lowerer.noLowering(".fill of a checked-dynamic reference into a static array", call.arguments.nodes[0]);
         }
         const writeUndefined = value === null || value.type.kind === "undefinedT" || value.type.kind === "void";
-        return lowerArrayFill(lowerer, lowerer.lowerExpr(access.expression), value, writeUndefined, lowerArrayPosition(lowerer, call.arguments[1], numLit(0, loc), "array fill start"), lowerArrayPosition(lowerer, call.arguments[2], numLit(Infinity, loc), "array fill end"), receiverIr, loc);
+        return lowerArrayFill(lowerer, lowerer.lowerExpr(access.expression), value, writeUndefined, lowerArrayPosition(lowerer, call.arguments.nodes[1], numLit(0, loc), "array fill start"), lowerArrayPosition(lowerer, call.arguments.nodes[2], numLit(Infinity, loc), "array fill end"), receiverIr, loc);
     }
     if (name === "copyWithin") {
-        if (call.arguments.length > 3 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.copyWithin with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length > 3 || call.arguments.nodes.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.copyWithin with ${call.arguments.nodes.length} arguments`, call);
         }
-        return lowerArrayCopyWithin(lowerer.lowerExpr(access.expression), lowerArrayPosition(lowerer, call.arguments[0], numLit(0, loc), "array copyWithin target"), lowerArrayPosition(lowerer, call.arguments[1], numLit(0, loc), "array copyWithin start"), lowerArrayPosition(lowerer, call.arguments[2], numLit(Infinity, loc), "array copyWithin end"), receiverIr, loc);
+        return lowerArrayCopyWithin(lowerer.lowerExpr(access.expression), lowerArrayPosition(lowerer, call.arguments.nodes[0], numLit(0, loc), "array copyWithin target"), lowerArrayPosition(lowerer, call.arguments.nodes[1], numLit(0, loc), "array copyWithin start"), lowerArrayPosition(lowerer, call.arguments.nodes[2], numLit(Infinity, loc), "array copyWithin end"), receiverIr, loc);
     }
     if (name === "with") {
-        if (call.arguments.length !== 2 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.with with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length !== 2 || call.arguments.nodes.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.with with ${call.arguments.nodes.length} arguments`, call);
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        const index = lowerPositionArgument(lowerer, call.arguments[0], numLit(0, loc));
+        const index = lowerPositionArgument(lowerer, call.arguments.nodes[0], numLit(0, loc));
         if (!primitivePositionType(lowerer, index.type)) {
-            lowerer.noLowering(`.with index of '${lowerer.fmt(index.type)}' values`, call.arguments[0]);
+            lowerer.noLowering(`.with index of '${lowerer.fmt(index.type)}' values`, call.arguments.nodes[0]);
         }
-        const value = lowerer.lowerExpr(call.arguments[1]);
+        const value = lowerer.lowerExpr(call.arguments.nodes[1]);
         const receiverLocal = lowerer.declareHiddenLocal("%withRecv", receiverIr);
         const indexLocal = lowerer.declareHiddenLocal("%withIndex", index.type);
         const valueLocal = lowerer.declareHiddenLocal("%withValue", value.type);
         const receiverRef = varRef(receiverLocal.id, receiverIr, loc);
         const indexRef = varRef(indexLocal.id, index.type, loc);
         const valueRef = varRef(valueLocal.id, value.type, loc);
-        const numericIndex = positionNumber(lowerer, indexRef, numLit(0, loc), call.arguments[0], "array with index");
+        const numericIndex = positionNumber(lowerer, indexRef, numLit(0, loc), call.arguments.nodes[0], "array with index");
         const stmts = [
             { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
             { kind: "varDecl", localId: indexLocal.id, init: index, loc },
@@ -480,7 +482,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        const coercedValue = lowerer.coerceInto(call.arguments[1], valueRef, elem);
+        const coercedValue = lowerer.coerceInto(call.arguments.nodes[1], valueRef, elem);
         return {
             kind: "seqExpr",
             stmts,
@@ -498,9 +500,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     }
     if (name === "toSpliced") {
         const receiver = lowerer.lowerExpr(access.expression);
-        const start = lowerArrayPosition(lowerer, call.arguments[0], numLit(0, loc), "array toSpliced start");
-        const deleteCount = lowerArrayPosition(lowerer, call.arguments[1], numLit(call.arguments.length === 1 ? Infinity : 0, loc), "array toSpliced deleteCount");
-        const itemNodes = call.arguments.slice(2);
+        const start = lowerArrayPosition(lowerer, call.arguments.nodes[0], numLit(0, loc), "array toSpliced start");
+        const deleteCount = lowerArrayPosition(lowerer, call.arguments.nodes[1], numLit(call.arguments.nodes.length === 1 ? Infinity : 0, loc), "array toSpliced deleteCount");
+        const itemNodes = call.arguments.nodes.slice(2);
         const hasSpread = itemNodes.some(ts.isSpreadElement);
         const itemProbes = hasSpread ? [] : itemNodes.map((arg) => tryLowerExpression(lowerer, arg));
         const statefulItems = itemProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null);
@@ -557,7 +559,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         reduce: [1, 2],
         reduceRight: [1, 2],
     }[name];
-    if (call.arguments.length < arity[0] || call.arguments.length > arity[1]) {
+    if (call.arguments.nodes.length < arity[0] || call.arguments.nodes.length > arity[1]) {
         const hint = name === "map" ||
             name === "filter" ||
             name === "forEach" ||
@@ -567,7 +569,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             name === "flatMap"
             ? "the thisArg parameter has no lowering — use an arrow function"
             : undefined;
-        lowerer.noLowering(`.${name} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"}`, call, hint);
+        lowerer.noLowering(`.${name} with ${call.arguments.nodes.length} argument${call.arguments.nodes.length === 1 ? "" : "s"}`, call, hint);
     }
     if (name === "push" || name === "unshift") {
         let receiver = lowerer.lowerExpr(access.expression);
@@ -583,8 +585,8 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         // `a.push(...src)` / `a.unshift(...src)`: copy src's elements in
         // order (count snapshotted first, so the self-spread forms duplicate
         // like JS) and return the new length.
-        const spreadArg = call.arguments.length === 1 && ts.isSpreadElement(call.arguments[0])
-            ? call.arguments[0]
+        const spreadArg = call.arguments.nodes.length === 1 && ts.isSpreadElement(call.arguments.nodes[0])
+            ? call.arguments.nodes[0]
             : null;
         if ((name === "push" || name === "unshift") && spreadArg && ts.isSpreadElement(spreadArg)) {
             let src = lowerer.lowerExpr(spreadArg.expression);
@@ -613,6 +615,10 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                     loc,
                 };
             }
+            if (!typeEquals(src.type, receiverIr)) {
+                // Fresh elements (an array literal) convert into the element layout.
+                src = liftedFreshSpread(lowerer, spreadArg.expression, src, receiverIr, loc) ?? src;
+            }
             if (!typeEquals(src.type, receiverIr)) {
                 lowerer.unsupported("SC1090", spreadArg, `${name === "push" ? "pushing" : "unshifting"} a spread of '${lowerer.fmt(src.type)}' onto a '${lowerer.fmt(receiverIr)}' array (only a same-element-type array spreads)`);
             }
@@ -625,11 +631,11 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        if (call.arguments.some(ts.isSpreadElement)) {
+        if (call.arguments.nodes.some(ts.isSpreadElement)) {
             // Finish argument evaluation before mutating the receiver. Each
             // spread snapshots its elements immediately, so a later argument
             // can mutate that source without changing already-collected values.
-            const items = lowerArraySpreadItems(lowerer, call.arguments, elem, receiverIr, loc);
+            const items = lowerArraySpreadItems(lowerer, call.arguments.nodes, elem, receiverIr, loc);
             return {
                 kind: "arrIntrinsic",
                 method: name === "push" ? "pushSpread" : "unshiftSpread",
@@ -639,12 +645,12 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        const valueProbes = call.arguments.map((arg) => tryLowerExpression(lowerer, arg));
+        const valueProbes = call.arguments.nodes.map((arg) => tryLowerExpression(lowerer, arg));
         if (valueProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null)) {
             if (name === "push") {
-                return lowerOptionalArrayPush(lowerer, receiver, call.arguments.map((arg) => lowerer.lowerExpr(arg)), elem, loc);
+                return lowerOptionalArrayPush(lowerer, receiver, call.arguments.nodes.map((arg) => lowerer.lowerExpr(arg)), elem, loc);
             }
-            const items = lowerArrayValueItems(lowerer, call.arguments.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc);
+            const items = lowerArrayValueItems(lowerer, call.arguments.nodes.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc);
             return {
                 kind: "arrIntrinsic",
                 method: "unshiftSpread",
@@ -657,7 +663,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         // Inserted values flow into the element slot like an assignment would:
         // union-element arrays wrap plain arm values (coerceInto is inert
         // when the types already agree).
-        const args = call.arguments.map((a) => name === "push" || name === "unshift"
+        const args = call.arguments.nodes.map((a) => name === "push" || name === "unshift"
             ? lowerer.lowerExprExpecting(a, elem)
             : lowerer.lowerExpr(a));
         return {
@@ -704,7 +710,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExpr(access.expression);
         const shape = [];
         const args = [];
-        for (const argNode of call.arguments) {
+        for (const argNode of call.arguments.nodes) {
             if (ts.isSpreadElement(argNode)) {
                 lowerer.unsupported("SC1090", argNode, "spread arguments to concat (pass the array itself — concat already spreads array arguments)");
             }
@@ -739,21 +745,21 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     if (name === "slice") {
         const receiver = lowerer.lowerExpr(access.expression);
         const args = [
-            lowerArrayPosition(lowerer, call.arguments[0], numLit(0, loc), "array slice start"),
-            lowerArrayPosition(lowerer, call.arguments[1], numLit(Infinity, loc), "array slice end"),
+            lowerArrayPosition(lowerer, call.arguments.nodes[0], numLit(0, loc), "array slice start"),
+            lowerArrayPosition(lowerer, call.arguments.nodes[1], numLit(Infinity, loc), "array slice end"),
         ];
         return { kind: "arrIntrinsic", method: "slice", receiver, args, type: receiverIr, loc };
     }
     if (name === "splice") {
         const receiver = lowerer.lowerExpr(access.expression);
         const args = [
-            lowerArrayPosition(lowerer, call.arguments[0], numLit(0, loc), "array splice start"),
-            lowerArrayPosition(lowerer, call.arguments[1], numLit(call.arguments.length === 1 ? Infinity : 0, loc), "array splice deleteCount"),
+            lowerArrayPosition(lowerer, call.arguments.nodes[0], numLit(0, loc), "array splice start"),
+            lowerArrayPosition(lowerer, call.arguments.nodes[1], numLit(call.arguments.nodes.length === 1 ? Infinity : 0, loc), "array splice deleteCount"),
         ];
-        if (call.arguments.length <= 2) {
+        if (call.arguments.nodes.length <= 2) {
             return { kind: "arrIntrinsic", method: "splice", receiver, args, type: receiverIr, loc };
         }
-        const itemNodes = call.arguments.slice(2);
+        const itemNodes = call.arguments.nodes.slice(2);
         const hasSpread = itemNodes.some(ts.isSpreadElement);
         const itemProbes = hasSpread ? [] : itemNodes.map((arg) => tryLowerExpression(lowerer, arg));
         const statefulItems = itemProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null);
@@ -797,14 +803,14 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     if (name === "join") {
         if (elem.kind === "dyn") {
             const receiver = lowerer.coerceToExpected(lowerer.lowerExpr(access.expression), DYN);
-            const args = call.arguments.length
-                ? [lowerer.lowerExprExpecting(call.arguments[0], DYN)]
+            const args = call.arguments.nodes.length
+                ? [lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)]
                 : [];
             return lowerer.coerceToExpected({
                 kind: "dynInvoke",
                 recv: receiver,
                 method: "join",
-                calleeName: access.getText(),
+                calleeName: ts.getTextOfNode(access),
                 args,
                 type: DYN,
                 loc,
@@ -827,7 +833,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             lowerer.unsupported("SC1090", call, "'.join()' on arrays of this element type (number, string, and boolean arrays join — unions of those with undefined/null arms too, the units printing empty like JS)");
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        const sep = lowerArrayJoinSeparator(lowerer, call.arguments[0], loc);
+        const sep = lowerArrayJoinSeparator(lowerer, call.arguments.nodes[0], loc);
         return { kind: "arrIntrinsic", method: "join", receiver, args: [sep], type: STRING, loc };
     }
     if (name === "map" || name === "filter" || name === "forEach") {
@@ -1015,8 +1021,8 @@ function literalFlatDepth(value) {
 }
 function lowerArrayFlatCall(lowerer, call, access, receiverType) {
     const loc = locOf(call);
-    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`.flat with ${call.arguments.length} arguments`, call);
+    if (call.arguments.nodes.length > 1 || call.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.flat with ${call.arguments.nodes.length} arguments`, call);
     }
     const elemCouldNest = (elem) => elem.kind === "array" ||
         elem.kind === "dyn" ||
@@ -1025,9 +1031,9 @@ function lowerArrayFlatCall(lowerer, call, access, receiverType) {
                 .get(elem.unionId)
                 ?.arms.some((arm) => arm.kind === "array" || arm.kind === "dyn") ??
                 true));
-    if (!elemCouldNest(receiverType.elem) && call.arguments[0]) {
+    if (!elemCouldNest(receiverType.elem) && call.arguments.nodes[0]) {
         const receiver = lowerer.lowerExpr(access.expression);
-        const depth = lowerArrayPosition(lowerer, call.arguments[0], numLit(1, loc), "array flat depth");
+        const depth = lowerArrayPosition(lowerer, call.arguments.nodes[0], numLit(1, loc), "array flat depth");
         const local = lowerer.declareHiddenLocal("%flatReceiver", receiverType);
         const ref = varRef(local.id, receiverType, loc);
         return {
@@ -1048,7 +1054,9 @@ function lowerArrayFlatCall(lowerer, call, access, receiverType) {
             loc,
         };
     }
-    const depth = call.arguments[0] ? literalFlatDepth(lowerer.lowerExpr(call.arguments[0])) : 1;
+    const depth = call.arguments.nodes[0]
+        ? literalFlatDepth(lowerer.lowerExpr(call.arguments.nodes[0]))
+        : 1;
     if (depth === null)
         lowerer.noLowering(".flat with a nonconstant depth", call);
     let remaining = Number.isNaN(depth) || depth <= 0 ? 0 : Math.trunc(depth);
@@ -1095,13 +1103,13 @@ function lowerArrayFlatCall(lowerer, call, access, receiverType) {
 function lowerArraySearchCall(lowerer, call, access, method, elem) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
-    if (call.arguments.some(ts.isSpreadElement))
+    if (call.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(`.${method} with spread arguments`, call);
-    const needle = call.arguments[0]
-        ? lowerer.lowerExpr(call.arguments[0])
+    const needle = call.arguments.nodes[0]
+        ? lowerer.lowerExpr(call.arguments.nodes[0])
         : { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc };
-    const fromIndex = call.arguments[1]
-        ? lowerPositionArgument(lowerer, call.arguments[1], numLit(0, loc))
+    const fromIndex = call.arguments.nodes[1]
+        ? lowerPositionArgument(lowerer, call.arguments.nodes[1], numLit(0, loc))
         : method === "lastIndexOf"
             ? { kind: "bin", op: "/", left: numLit(1, loc), right: numLit(0, loc), type: F64, loc }
             : numLit(0, loc);
@@ -1109,7 +1117,7 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
 }
 function lowerArraySearchValues(lowerer, call, method, elem, receiver, needle, fromIndex) {
     const loc = locOf(call);
-    const argNode = call.arguments[0] ?? call;
+    const argNode = call.arguments.nodes[0] ?? call;
     // A derived CLASS VALUE against a base-classval element widens (the same
     // pointer — identity search is exact); the coercion path owns the ABI gate.
     if (needle.type.kind === "classval" &&
@@ -1120,7 +1128,7 @@ function lowerArraySearchValues(lowerer, call, method, elem, receiver, needle, f
     // Preserve the existing fast path for an ordinary, non-union needle. Its
     // runtime implementation already has exact primitive/reference equality.
     if (method !== "lastIndexOf" &&
-        call.arguments.length === 1 &&
+        call.arguments.nodes.length === 1 &&
         elem.kind !== "union" &&
         elem.kind !== "bigint" &&
         typeEquals(needle.type, elem)) {
@@ -1139,7 +1147,7 @@ function lowerArraySearchValues(lowerer, call, method, elem, receiver, needle, f
     if (valueT.kind !== "union") {
         if (method === "lastIndexOf")
             lowerer.noLowering(".lastIndexOf on an array of checked values", call);
-        if (call.arguments.length > 1)
+        if (call.arguments.nodes.length > 1)
             lowerer.noLowering(`.${method} with fromIndex on '${lowerer.fmt(elem)}' elements`, call);
         if (!typeEquals(needle.type, elem))
             lowerer.badType(argNode, lowerer.typeOf(argNode));
@@ -1183,7 +1191,7 @@ function lowerArraySearchValues(lowerer, call, method, elem, receiver, needle, f
     }
     if (!directNeedle && !typeEquals(searchNeedle.type, valueT))
         lowerer.badType(argNode, lowerer.typeOf(argNode));
-    const helper = arraySearchHelper(lowerer, method, elem, valueT, searchNeedle.type, directNeedle, fromIndex.type, call.arguments[1] ?? call, loc);
+    const helper = arraySearchHelper(lowerer, method, elem, valueT, searchNeedle.type, directNeedle, fromIndex.type, call.arguments.nodes[1] ?? call, loc);
     return {
         kind: "call",
         callee: helper,
@@ -1536,11 +1544,17 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
         return null;
     const method = access.name.text;
     const search = method === "includes" || method === "indexOf" || method === "lastIndexOf";
+    const predicate = method === "filter" ||
+        method === "find" ||
+        method === "findIndex" ||
+        method === "some" ||
+        method === "every";
     if (method !== "slice" &&
         method !== "map" &&
         method !== "flatMap" &&
         method !== "join" &&
-        !search)
+        !search &&
+        !predicate)
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
@@ -1597,10 +1611,10 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
         loc,
     }, elem);
     if (search) {
-        if (call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
+        if (call.arguments.nodes.length > 2 || call.arguments.nodes.some(ts.isSpreadElement)) {
             return lowerer.noLowering(`tuple .${method} with spread or extra arguments`, call);
         }
-        const arg = call.arguments[0];
+        const arg = call.arguments.nodes[0];
         const undefinedArg = arg ? lowerStaticallyUndefinedArgument(lowerer, arg) : null;
         let needle = arg ? (undefinedArg ?? lowerer.lowerExpr(arg)) : null;
         if (!needle || isUnitType(needle.type) || needle.type.kind === "void") {
@@ -1612,10 +1626,10 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
                 return lowerer.noLowering(`tuple .${method} missing search value`, call);
             needle = needle ? defaultAfterUndefined(needle, wrapped) : wrapped;
         }
-        const from = call.arguments[1]
-            ? lowerPositionArgument(lowerer, call.arguments[1], numLit(0, loc))
+        const from = call.arguments.nodes[1]
+            ? lowerPositionArgument(lowerer, call.arguments.nodes[1], numLit(0, loc))
             : numLit(method === "lastIndexOf" ? Infinity : 0, loc);
-        const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(needle.type)}:${typeKey(from.type)}:${call.arguments.length}`;
+        const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(needle.type)}:${typeKey(from.type)}:${call.arguments.nodes.length}`;
         let helper = lowerer.arrHofHelpers.get(key);
         const resultType = method === "includes" ? BOOL : F64;
         if (!helper) {
@@ -1644,7 +1658,7 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
                     {
                         kind: "varDecl",
                         localId: "position.0",
-                        init: positionNumber(lowerer, varRef("from.0", from.type, loc), numLit(0, loc), call.arguments[1] ?? call, "tuple search position"),
+                        init: positionNumber(lowerer, varRef("from.0", from.type, loc), numLit(0, loc), call.arguments.nodes[1] ?? call, "tuple search position"),
                         loc,
                     },
                     { kind: "return", value: result, loc },
@@ -1655,13 +1669,13 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
         return { kind: "call", callee: helper, args: [receiver, needle, from], type: resultType, loc };
     }
     if (method === "slice") {
-        if (call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.slice with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length > 2 || call.arguments.nodes.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.slice with ${call.arguments.nodes.length} arguments`, call);
         }
-        const args = call.arguments.map((arg) => lowerer.lowerExpr(arg));
+        const args = call.arguments.nodes.map((arg) => lowerer.lowerExpr(arg));
         args.forEach((arg, i) => {
             if (arg.type.kind !== "f64")
-                lowerer.badType(call.arguments[i], lowerer.typeOf(call.arguments[i]));
+                lowerer.badType(call.arguments.nodes[i], lowerer.typeOf(call.arguments.nodes[i]));
         });
         const resultType = arrayOf(elem);
         const key = `tuple.slice:${typeKey(receiver.type)}:${args.length}`;
@@ -1703,15 +1717,18 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
         }
         return { kind: "call", callee: helper, args: [receiver, ...args], type: resultType, loc };
     }
-    if (call.arguments.length !== 1 || call.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`.${method} with ${call.arguments.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
+    if (call.arguments.nodes.length !== 1 || call.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.${method} with ${call.arguments.nodes.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
     }
-    const callback = call.arguments[0];
+    const callback = call.arguments.nodes[0];
     // Check before the array HOF adapter can create a tuple-to-array copy.
     const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(callback));
     if (signatures.some((signature) => signature.getParameters().length > 2)) {
         lowerer.noLowering(`tuple .${method} callback array parameter`, callback, "capture the original tuple explicitly to preserve its identity");
     }
+    if (predicate) {
+        return lowerTuplePredicateCall(lowerer, call, method, receiver, elem, fields.map(read));
+    }
     const { fnArg, arity } = lowerArrayCallback(lowerer, callback, [elem], receiver.type);
     const ret = fnArg.type.ret;
     if (ret.kind === "void" || ret.kind === "func")
@@ -1722,7 +1739,7 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
             kind: "dynInvoke",
             recv: { kind: "dynFrom", value: receiver, type: DYN, loc },
             method: "flatMap",
-            calleeName: access.getText(),
+            calleeName: ts.getTextOfNode(access),
             args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }],
             type: DYN,
             loc,
@@ -1836,10 +1853,10 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
  * through). */
 function lowerArrayAtCall(lowerer, call, access, elem) {
     const loc = locOf(call);
-    if (call.arguments.some(ts.isSpreadElement))
+    if (call.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(".at with spread arguments", call);
     const receiver = lowerer.lowerExpr(access.expression);
-    const indexNode = call.arguments[0];
+    const indexNode = call.arguments.nodes[0];
     const index = lowerPositionArgument(lowerer, indexNode, numLit(0, loc));
     const resultT = lowerer.irTypeOf(call);
     if (resultT.kind !== "union")