@scriptc/compiler 0.2.5 → 0.2.7

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

@@ -1,7 +1,10 @@
 import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js";
+import { transformStmtList } from "../../../ir/traverse.js";
 import { InternalCompilerError } from "../../../errors.js";
+import { canAssertClassValue, checkedClassAssertion } from "../class-assertions.js";
 import * as ts from "../../ts7/adapter.js";
-import { BOOL, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isUnitType, typeEquals, } from "../../../ir/ir.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 } from "../lower-array-sort.js";
 import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent, } from "../array-values.js";
@@ -9,6 +12,7 @@ import { typeKey } from "../../type-mapper.js";
 import { lowerArrayCallback, requireProducedArrayElement, callbackArrayElement, } 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";
 /** `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
@@ -69,9 +73,19 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
     const outElem = method === "filter"
         ? filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter)
         : callbackArrayElement(lowerer, call, fnRet);
-    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem);
+    // A filter that re-tags its elements keeps the single union-typed visit.
+    const fast = 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);
     const resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
-    return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultType, loc };
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg, ...(fast ? [fast] : [])],
+        type: resultType,
+        loc,
+    };
 }
 /** The checker-selected element of a filter result, with the same trust
  * boundary as the historical narrowing filter: an inferred inline type
@@ -111,13 +125,15 @@ function filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
                 `unchecked assertion nothing validates at runtime — ${annotateEscape})`);
         }
     }
-    if (valueT.kind !== "union" || lowerer.armTag(valueT.unionId, outElem) < 0) {
+    const classRefinement = !booleanFilter && outElem.kind === "object" && canAssertClassValue(lowerer, valueT, outElem);
+    if (!classRefinement &&
+        (valueT.kind !== "union" || lowerer.armTag(valueT.unionId, outElem) < 0)) {
         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)}'`} ` +
             `(${multiArm ? "only a SINGLE arm re-tags" : "only a single runtime arm re-tags"} — ${annotateEscape})`);
     }
-    if (booleanFilter) {
+    if (booleanFilter && valueT.kind === "union") {
         const arms = lowerer.unions.get(valueT.unionId)?.arms ?? [];
         if (arms.some((arm) => !typeEquals(arm, outElem) && !isUnitType(arm))) {
             lowerer.unsupported("SC1090", call, `'.filter(Boolean)' narrowing '${lowerer.fmt(elem)}' to '${lowerer.fmt(outElem)}' ` +
@@ -193,18 +209,193 @@ function filterCond(call, fnRet, loc) {
     // the runtime's kind-aware ToBoolean.
     return { kind: "toBool", operand: call, type: BOOL, loc };
 }
+/** Nested HOFs inside a fast lowering keep their single union visit, so
+ * duplication stays linear in nesting depth. */
+let fastLoweringDepth = 0;
+/** Array reads widen elements with undefined so holes and present
+ * undefined stay observable, which makes every callback parameter a boxed
+ * `T | undefined`. For an inline arrow over a plain element type, lower the
+ * callback a second time with the element type itself. The helper then
+ * splits each visit on the element state: a present value calls this fast
+ * closure with the plain element (no union box, no per-use undefined
+ * test), and a hole or present undefined calls the original closure with
+ * the undefined arm. Both closures share the same capture boxes and body,
+ * so every observable effect is the same; arrows have no own `this`,
+ * `arguments` or self binding that could tell the two apart. Any refusal
+ * in the second lowering is discarded and keeps the single visit. */
+function lowerFastCallback(lowerer, argNode, lead, elemIndex, elem, arrT, slow, bindUntyped = false, expectedReturn) {
+    const valueT = lead[elemIndex];
+    if (fastLoweringDepth > 0 ||
+        slow.arity <= elemIndex ||
+        !ts.isArrowFunction(argNode) ||
+        isJsSourceFile(argNode.getSourceFile()) ||
+        valueT?.kind !== "union" ||
+        typeEquals(valueT, elem) ||
+        elem.kind === "union" ||
+        elem.kind === "dyn" ||
+        elem.kind === "jsval" ||
+        isUnitType(elem))
+        return null;
+    const fastLead = lead.slice();
+    fastLead[elemIndex] = elem;
+    // 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];
+    if (!param || param.initializer || param.dotDotDotToken || !ts.isIdentifier(param.name))
+        return null;
+    const symbol = param.type ? undefined : lowerer.checker.getSymbolAtLocation(param.name);
+    const previousBinding = symbol ? lowerer.runtimeOptionalBindingTypes.get(symbol) : undefined;
+    if (symbol)
+        lowerer.runtimeOptionalBindingTypes.set(symbol, elem);
+    const sink = [];
+    const previousSink = lowerer.diagSink;
+    lowerer.diagSink = sink;
+    fastLoweringDepth++;
+    let fast;
+    try {
+        fast = lowerArrayCallback(lowerer, argNode, fastLead, arrT, bindUntyped, expectedReturn);
+    }
+    catch (e) {
+        if (e instanceof PoisonError)
+            return null;
+        throw e;
+    }
+    finally {
+        fastLoweringDepth--;
+        lowerer.diagSink = previousSink;
+        if (symbol) {
+            if (previousBinding === undefined)
+                lowerer.runtimeOptionalBindingTypes.delete(symbol);
+            else
+                lowerer.runtimeOptionalBindingTypes.set(symbol, previousBinding);
+        }
+    }
+    const fastT = fast.fnArg.type;
+    const slowT = slow.fnArg.type;
+    if (fast.fnArg.kind !== "closure" ||
+        fast.arity !== slow.arity ||
+        !typeEquals(fastT.ret, slowT.ret) ||
+        !fastT.params.every((param, i) => typeEquals(param, i === elemIndex ? elem : slowT.params[i])))
+        return null;
+    return fast.fnArg;
+}
+/** `a[i]` holds a value (array state 1): neither a hole nor a present
+ * undefined. */
+function presentValue(arr, index, loc) {
+    return {
+        kind: "bin",
+        op: "===",
+        left: { kind: "arrayState", arr, index, type: F64, loc },
+        right: numLit(1, loc),
+        type: BOOL,
+        loc,
+    };
+}
+/** Route a helper's callback calls through the split visit: every
+ * `f(<arrayValueRead a[i]>, ...)` becomes
+ * `state(a, i) === 1 ? fast(a[i], ...) : f(undefined, ...)`. The read is
+ * the call's only effectful operand (the rest are the loop's index and
+ * array locals), so evaluation order is unchanged. The fast closure is an
+ * extra trailing parameter. */
+function withFastCallback(fn, fastT, elem) {
+    if (!fastT)
+        return fn;
+    const isValueRead = (e) => e.kind === "ternary" &&
+        e.cond.kind === "bin" &&
+        e.cond.op === "===" &&
+        e.cond.left.kind === "arrayState" &&
+        e.cond.right.kind === "numLit" &&
+        e.cond.right.value === 1;
+    const split = (e) => {
+        if (e.kind !== "callValue" || e.callee.kind !== "varRef" || e.callee.localId !== "f.0")
+            return null;
+        const at = e.args.findIndex(isValueRead);
+        if (at < 0)
+            return null;
+        const read = e.args[at];
+        if (read.kind !== "ternary")
+            return null;
+        const condition = read.cond;
+        if (condition.kind !== "bin")
+            return null;
+        const state = condition.left;
+        if (state.kind !== "arrayState")
+            return null;
+        const fastArgs = e.args.slice();
+        fastArgs[at] = {
+            kind: "arrayGet",
+            arr: state.arr,
+            index: state.index,
+            type: elem,
+            loc: read.loc,
+        };
+        const slowArgs = e.args.slice();
+        slowArgs[at] = read.else_;
+        return {
+            cond: read.cond,
+            fast: { ...e, callee: varRef("fast.0", fastT, e.callee.loc), args: fastArgs },
+            slow: { ...e, args: slowArgs },
+        };
+    };
+    const body = transformStmtList(fn.body, {
+        stmt: (stmt) => {
+            if (stmt.kind !== "exprStmt")
+                return stmt;
+            const parts = split(stmt.expr);
+            if (!parts)
+                return stmt;
+            return {
+                kind: "if",
+                cond: parts.cond,
+                then: [{ kind: "exprStmt", expr: parts.fast, loc: stmt.loc }],
+                else_: [{ kind: "exprStmt", expr: parts.slow, loc: stmt.loc }],
+                loc: stmt.loc,
+            };
+        },
+        expr: (expr) => {
+            const parts = split(expr);
+            if (!parts)
+                return expr;
+            return {
+                kind: "ternary",
+                cond: parts.cond,
+                then: parts.fast,
+                else_: parts.slow,
+                type: expr.type,
+                loc: expr.loc,
+            };
+        },
+    });
+    return {
+        ...fn,
+        params: [...fn.params, { localId: "fast.0", name: "fast", type: fastT }],
+        locals: [...fn.locals, { id: "fast.0", name: "fast", type: fastT, mutable: true }],
+        body,
+    };
+}
+/** 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. */
+function callbackSite(fnArg) {
+    return fnArg.kind === "closure" ? `@${fnArg.fnName}` : "";
+}
 /** Interned synthetic loop function for one (method, elem, fnRet, arity)
  * combo. Named `%arr.<method>.<n>` ('%' keeps it out of the user
  * namespace); rides `liftedFns` into the module like a lifted lambda (it
  * is a plain function — no captures). */
-function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}`;
+function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
-    lowerer.liftedFns.push(buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem));
+    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT);
+    lowerer.liftedFns.push(fastT ? withFastCallback(fn, fastT, elem) : fn);
     return name;
 }
 /** The TS 5.2+ callable-union array rule: a `T[] | U[]` receiver exposes
@@ -362,7 +553,7 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
  * `arity` is the callback's declared parameter count (1–3): the loop
  * passes the index and the receiver itself after the element when the
  * callback names them, exactly the arguments JS supplies. */
-function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem) {
+function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null) {
     const arrT = arrayOf(elem);
     const valueT = arrayValueType(lowerer, elem);
     const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
@@ -427,22 +618,111 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
             { kind: "return", value: varRef("out.0", outT, loc), loc },
         ];
     }
+    else if (method === "filter" && fastT) {
+        // Split visit (outElem === elem): a present value goes to the fast
+        // callback as a plain element and is kept as-is; a present undefined
+        // goes to the original callback and is kept as undefined.
+        const outT = arrayOf(outElem);
+        locals.push({ id: "out.0", name: "out", type: outT, mutable: false }, { id: "e.0", name: "e", type: elem, mutable: false });
+        returnType = outT;
+        const a = varRef("a.0", arrT, loc);
+        const i = varRef("i.0", F64, loc);
+        const outLength = {
+            kind: "arrIntrinsic",
+            method: "length",
+            receiver: varRef("out.0", outT, loc),
+            args: [],
+            type: F64,
+            loc,
+        };
+        const missing = getElem.else_;
+        const callFast = (arg) => ({
+            kind: "callValue",
+            callee: varRef("fast.0", fastT, loc),
+            args: [arg, i, a].slice(0, arity),
+            type: fnRet,
+            loc,
+        });
+        body = [
+            {
+                kind: "varDecl",
+                localId: "out.0",
+                init: { kind: "arrayLit", elems: [], type: outT, loc },
+                loc,
+            },
+            readLen,
+            forLoop([
+                {
+                    kind: "if",
+                    cond: hasElem,
+                    then: [
+                        {
+                            kind: "if",
+                            cond: presentValue(a, i, loc),
+                            then: [
+                                {
+                                    kind: "varDecl",
+                                    localId: "e.0",
+                                    init: { kind: "arrayGet", arr: a, index: i, type: elem, loc },
+                                    loc,
+                                },
+                                {
+                                    kind: "if",
+                                    cond: filterCond(callFast(varRef("e.0", elem, loc)), fnRet, loc),
+                                    then: [
+                                        arrayValueStore(lowerer, varRef("out.0", outT, loc), outLength, varRef("e.0", elem, loc), outElem, loc),
+                                    ],
+                                    else_: null,
+                                    loc,
+                                },
+                            ],
+                            else_: [
+                                {
+                                    kind: "if",
+                                    cond: filterCond(callF(missing), fnRet, loc),
+                                    then: [
+                                        {
+                                            kind: "arraySetUndefined",
+                                            arr: varRef("out.0", outT, loc),
+                                            index: outLength,
+                                            loc,
+                                        },
+                                    ],
+                                    else_: null,
+                                    loc,
+                                },
+                            ],
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                },
+            ]),
+            { kind: "return", value: varRef("out.0", outT, loc), loc },
+        ];
+    }
     else if (method === "filter") {
         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)
-            : 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);
+            : 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);
         body = [
             {
                 kind: "varDecl",
@@ -538,13 +818,15 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
         method === "every" ||
         method === "findIndex" ||
         method === "findLastIndex") {
+        const fast = lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity }, bindUntyped);
+        const fastT = fast?.type ?? null;
         const helper = method === "findIndex" || method === "findLastIndex"
-            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc)
-            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc);
+            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT)
+            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT);
         return {
             kind: "call",
             callee: helper,
-            args: [receiver, fnArg],
+            args: [receiver, fnArg, ...(fast ? [fast] : [])],
             type: method === "findIndex" || method === "findLastIndex" ? F64 : BOOL,
             loc,
         };
@@ -580,10 +862,12 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
             lowerer.unsupported("SC1090", call, `'.${method}' result narrowing without a predicate over its element`);
         }
         retag = lowerer.narrowedRetagHelper(call, valueT.unionId, resultT.unionId, loc);
-        if (retag === null)
+        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 helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag);
+    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg));
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
 }
 /** ToBoolean of a predicate result inside a synthesized HOF helper — the
@@ -602,9 +886,9 @@ function predicateToBoolean(e) {
  *   for (i = 0; i < n; i++) { v = a[i]; if (f(v)) return <v as result arm>; }
  *   return <undefined arm>;
  */
-function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag) {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "") {
     const method = last ? "findLast" : "find";
-    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -614,8 +898,14 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
     const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const valueT = arrayValueType(lowerer, elem);
     const v = varRef("v.0", valueT, loc);
+    const present = 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) && present.kind === "object"
+        ? checkedClassAssertion(lowerer, v, present, loc)
+        : null;
     const found = retag === null
-        ? lowerer.coerceToExpected(v, resultT)
+        ? lowerer.coerceToExpected(classView ?? v, resultT)
         : { kind: "call", callee: retag, args: [v], type: resultT, loc };
     const miss = {
         kind: "unionWrap",
@@ -667,9 +957,9 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
  *
  *   n = a.length; for (...) if (f(a[i], i, a)) return i;  return -1;
  */
-function findIndexHelper(lowerer, elem, fnRet, arity, last, loc) {
+function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null) {
     const method = last ? "findLastIndex" : "findIndex";
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -694,14 +984,14 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc) {
         loop,
         { kind: "return", value: { kind: "numLit", value: -1, type: F64, loc }, loc },
     ];
-    lowerer.liftedFns.push({
+    lowerer.liftedFns.push(withFastCallback({
         name,
         params: arrayCallbackParams(arrT, fnT),
         returnType: F64,
         locals: [...arrayCallbackLocals(arrT, fnT)],
         body,
         loc,
-    });
+    }, fastT, elem));
     return name;
 }
 /** The some/every loops — short-circuit early returns, JS-exact:
@@ -709,8 +999,8 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc) {
  *   some:  n = a.length; for (...) if (f(a[i])) return true;  return false;
  *   every: n = a.length; for (...) if (!f(a[i])) return false; return true;
  */
-function someEveryHelper(lowerer, method, elem, fnRet, arity, loc) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}`;
+function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -742,14 +1032,14 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc) {
         ]),
         { kind: "return", value: boolLit(method !== "some", loc), loc },
     ];
-    lowerer.liftedFns.push({
+    lowerer.liftedFns.push(withFastCallback({
         name,
         params: arrayCallbackParams(arrT, fnT),
         returnType: BOOL,
         locals: [...arrayCallbackLocals(arrT, fnT)],
         body,
         loc,
-    });
+    }, fastT, elem));
     return name;
 }
 /** `a.flatMap(f)` — map plus a one-level flatten. A callback returning
@@ -793,11 +1083,28 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             lowerer.badType(call, lowerer.typeOf(call));
         requireProducedArrayElement(lowerer, call, "'.flatMap()'", fnRet);
         const outElem = callbackArrayElement(lowerer, call, fnRet);
-        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem);
-        return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrayOf(outElem), loc };
+        const fast = lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity });
+        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null);
+        return {
+            kind: "call",
+            callee: helper,
+            args: [receiver, fnArg, ...(fast ? [fast] : [])],
+            type: arrayOf(outElem),
+            loc,
+        };
     }
-    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc);
-    return { kind: "call", callee: helper, args: [receiver, fnArg], type: fnRet, loc };
+    const fast = lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
+        fnArg,
+        arity,
+    });
+    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null);
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg, ...(fast ? [fast] : [])],
+        type: fnRet,
+        loc,
+    };
 }
 /** The flatMap loop (array-returning callback), from existing IR nodes:
  *
@@ -808,8 +1115,8 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
  *   }
  *   return out;
  */
-function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
-    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}`;
+function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null) {
+    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -908,7 +1215,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
         ]),
         { kind: "return", value: varRef("out.0", fnRet, loc), loc },
     ];
-    lowerer.liftedFns.push({
+    lowerer.liftedFns.push(withFastCallback({
         name,
         params: arrayCallbackParams(arrT, fnT),
         returnType: fnRet,
@@ -922,7 +1229,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
         ],
         body,
         loc,
-    });
+    }, fastT, elem));
     return name;
 }
 /** `a.reduce(f)` / `a.reduce(f, init)` and reduceRight — both declared
@@ -943,10 +1250,15 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
     if (accT.kind === "void" || accT.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
     const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT, false, accT);
-    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc);
+    const fast = lowerFastCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], 1, elem, arrT, { fnArg, arity }, false, accT);
+    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc, callbackSite(fast ?? fnArg), fast?.type ?? null);
     const args = [receiver, fnArg];
     if (hasInit)
         args.push(lowerer.lowerExprExpecting(call.arguments[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)
+        args.push(fast);
     return { kind: "call", callee: helper, args, type: accT, loc };
 }
 /** The reduce/reduceRight loops, from existing IR nodes:
@@ -959,8 +1271,8 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
  * reduce walks 0→n-1, reduceRight n-1→0; the seed without an initial
  * value is a[0] / a[n-1] and the loop starts one past it. The empty-array
  * TypeError message is Node's, byte for byte. */
-function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}`;
+function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, site = "", fastT = null) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1100,53 +1412,77 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc) {
         loop,
         { kind: "return", value: varRef("acc.0", accT, loc), loc },
     ];
-    lowerer.liftedFns.push({ name, params, returnType: accT, locals, body, loc });
+    lowerer.liftedFns.push(withFastCallback({ name, params, returnType: accT, locals, body, loc }, fastT, elem));
     return name;
 }
 /** `a.sort(cmp)` / `a.toSorted(cmp)`, desugared to an interned synthetic
  * function like the other array HOFs. sort mutates and returns the receiver;
  * toSorted takes its shallow snapshot INSIDE the helper, after the receiver
  * and comparator expressions have both been evaluated, then sorts and
- * returns that copy without touching the receiver. The helper uses a stable
- * bottom-up merge sort with an ordered-boundary check: ordered inputs use a
- * linear number of comparator calls, but buffer movement remains O(n log n)
- * even when every boundary is already ordered. During a merge, an element
+ * returns that copy without touching the receiver. The helper merges stable
+ * natural runs, reversing only strict descending runs and extending short
+ * runs with insertion sort. Ordered boundaries skip merging. During a merge, an element
  * moves right only while cmp(left, right) > 0, so a NaN or 0 result keeps
  * the left element first. Undefined values sink without reaching the user
  * comparator. The callback sequence differs from V8's TimSort, so exact
  * order and count parity are not claimed; results agree for consistent
- * comparators. The comparator-less form lowers for STRING elements only —
- * JS's default converts every element to string and compares UTF-16 units,
- * so the interned synthesized comparator selects the runtime's code-unit
- * ordering rather than scriptc's documented code-point relational
- * operators. For numbers that default is the notorious string sort
- * ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
- * comparator. */
+ * comparators. Without a comparator, string, number and boolean arrays use
+ * native stable ordering: their String conversions cannot call user code.
+ * Strings compare UTF-16 units; numbers compare their decimal spellings
+ * ([10, 9, 1] → [1, 10, 9]). Other element types still need a comparator. */
 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 && elem.kind === "string") {
-        const receiver = lowerer.lowerExpr(access.expression);
-        const cmp = defaultStringCmpHelper(lowerer, loc);
-        const fnT = funcOf([STRING, STRING], F64);
-        const key = `${method}:${typeKey(STRING)}:2`;
-        let helper = lowerer.arrHofHelpers.get(key);
-        if (!helper) {
-            helper = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
-            lowerer.arrHofHelpers.set(key, helper);
-            lowerer.liftedFns.push(buildArraySortFn(helper, STRING, 2, copyFirst, null, loc));
-        }
-        const fnArg = { kind: "closure", fnName: cmp, captures: [], type: fnT, loc };
-        return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrT, loc };
+    if (call.arguments.length === 0 &&
+        (elem.kind === "string" || elem.kind === "f64" || elem.kind === "bool")) {
+        return {
+            kind: "arrIntrinsic",
+            method: copyFirst ? "toSortedPrimitive" : "sortPrimitive",
+            receiver: lowerer.lowerExpr(access.expression),
+            args: [],
+            type: arrT,
+            loc,
+        };
     }
     if (call.arguments.length !== 1) {
-        lowerer.noLowering(`.${method} with ${call.arguments.length} arguments`, call, "the default string-conversion ordering lowers only for string[] — pass a comparator: " +
-            `${method}((a, b) => a - b) for numbers`);
+        lowerer.noLowering(`.${method} with ${call.arguments.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];
-    let fnArg = lowerer.lowerExpr(argNode);
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, argNode);
+    let unwrappedArg = argNode;
+    while (ts.isParenthesizedExpression(unwrappedArg) ||
+        ts.isAsExpression(unwrappedArg) ||
+        ts.isTypeAssertion(unwrappedArg) ||
+        ts.isSatisfiesExpression(unwrappedArg))
+        unwrappedArg = unwrappedArg.expression;
+    if (undefinedArg?.type.kind === "void" && !ts.isVoidExpression(unwrappedArg)) {
+        lowerer.noLowering(`.${method} with an erased comparator result`, argNode, "pass the comparator directly, or use void expression to explicitly select default ordering");
+    }
+    if (undefinedArg !== null &&
+        (undefinedArg.type.kind === "undefinedT" || ts.isVoidExpression(unwrappedArg)) &&
+        (elem.kind === "string" || elem.kind === "f64" || elem.kind === "bool")) {
+        // A type assertion alone cannot turn a function value into undefined.
+        // The explicit undefined expression can mutate or replace the receiver.
+        // Keep its original value alive and run the argument before sorting.
+        const saved = lowerer.declareHiddenLocal("%sortReceiver", arrT);
+        return {
+            kind: "seqExpr",
+            stmts: [{ kind: "varDecl", localId: saved.id, init: receiver, loc }],
+            result: defaultAfterUndefined(undefinedArg, {
+                kind: "arrIntrinsic",
+                method: copyFirst ? "toSortedPrimitive" : "sortPrimitive",
+                receiver: varRef(saved.id, arrT, loc),
+                args: [],
+                type: arrT,
+                loc,
+            }),
+            type: arrT,
+            loc,
+        };
+    }
+    let fnArg = undefinedArg ?? lowerer.lowerExpr(argNode);
     // Reusable JS comparators often accept checked values. Adapt the array's
     // element ABI just as other array callbacks do before sorting.
     if (fnArg.type.kind === "func" &&
@@ -1171,76 +1507,19 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
         lowerer.badType(argNode, lowerer.typeOf(argNode));
     }
     const arity = fnArg.type.params.length;
-    const key = `${method}:${typeKey(elem)}:${arity}`;
+    // 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 key = `${method}:${typeKey(elem)}:${arity}${native ? ":native" : ""}`;
     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));
+        lowerer.liftedFns.push(buildArraySortFn(helper, elem, arity, copyFirst, undefinedTag >= 0 ? undefinedTag : null, loc, native));
     }
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrT, loc };
 }
-/** JS's default sort comparator for STRING elements, interned once:
- *
- *   (a, b) => a < b ? -1 : a > b ? 1 : 0
- *
- * The dedicated UTF-16 comparison flag keeps this exact across
- * supplementary-plane code points and U+E000..U+FFFF, where the runtime's
- * ordinary code-point relational order deliberately differs. */
-function defaultStringCmpHelper(lowerer, loc) {
-    const key = "sortCmpStr";
-    const existing = lowerer.arrHofHelpers.get(key);
-    if (existing)
-        return existing;
-    const name = `%arr.sortCmpStr`;
-    lowerer.arrHofHelpers.set(key, name);
-    const cmp = (op) => ({
-        kind: "strCmp",
-        op,
-        left: varRef("a.0", STRING, loc),
-        right: varRef("b.0", STRING, loc),
-        utf16: true,
-        type: BOOL,
-        loc,
-    });
-    const body = [
-        {
-            kind: "return",
-            value: {
-                kind: "ternary",
-                cond: cmp("<"),
-                then: numLit(-1, loc),
-                else_: {
-                    kind: "ternary",
-                    cond: cmp(">"),
-                    then: numLit(1, loc),
-                    else_: numLit(0, loc),
-                    type: F64,
-                    loc,
-                },
-                type: F64,
-                loc,
-            },
-            loc,
-        },
-    ];
-    lowerer.liftedFns.push({
-        name,
-        params: [
-            { localId: "a.0", name: "a", type: STRING },
-            { localId: "b.0", name: "b", type: STRING },
-        ],
-        returnType: F64,
-        locals: [
-            { id: "a.0", name: "a", type: STRING, mutable: true },
-            { id: "b.0", name: "b", type: STRING, mutable: true },
-        ],
-        body,
-        loc,
-    });
-    return name;
-}
 /** `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
  * over the dyn value, and each SURVIVOR is validated-extracted into the