@scriptc/compiler 0.4.1 → 0.4.3

package/dist/backend/llvm/emit-statements.js

@@ -11,24 +11,32 @@ import { allocateLocalUnion, storeLocalUnion } from "./local-union-storage.js";
 import { boxAccess, boxNewCall, elemAccess } from "./shapes.js";
 import { dynHoleRead } from "./loop-array-borrows.js";
 import { endsWithJump, matchStringSelfConcat } from "../../ir/analysis.js";
-import { emitDiscardedSplice } from "./expr-containers.js";
+import { charAtUnitRead, emitDiscardedSplice } from "./expr-containers.js";
 import { InternalCompilerError } from "../../errors.js";
-import { emitDenseArrayGet, emitDenseArrayPop, emitDenseArraySet } from "./dense-array-access.js";
+import { emitDenseArrayGet, emitDenseArrayPop, emitDenseArraySet, SCR_ELEM_I32, } from "./dense-array-access.js";
 import { emitBorrowedInput } from "./borrowed-inputs.js";
-import { f64Lit, llvmCommentText, loadArrCount, sizeToDouble } from "./common.js";
-import { RESULT_DST_ID, RESULT_ENTRY_PREFIX } from "./record-results.js";
-import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, } from "../../ir/integer-loops.js";
+import { f64Lit, llvmCommentText, loadArrCount, SCR_ARR_FIELD, sizeToDouble } from "./common.js";
+import { planInt32KindLoop } from "./int32-kind-loops.js";
+import { withinInt32 } from "../../ir/integer-ranges.js";
+import { resultSlotStore } from "../result-slots.js";
+import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop, matchIntegerPairedForLoop, } from "../../ir/integer-loops.js";
 import { emitByteWindowGuard, matchByteWindow } from "./byte-windows.js";
-import { countedDenseShape, emitDenseLoopGuard, matchDenseArrayLoop } from "./dense-array-loops.js";
-import { emitCountedLoopLimit, emitCountedLoopSafety } from "./counted-loops.js";
+import { countedDenseShape, emitDenseLoopGuard, matchDenseArrayLoop, pairedDenseShape, } from "./dense-array-loops.js";
+import { emitCountedLoopLimit, emitCountedLoopSafety, emitPairedLoopSafety, } from "./counted-loops.js";
 import { emitBytesLoopVersionGuard } from "./bytes-loop-versions.js";
+import { bytesHeaderAlias } from "./bytes-alias.js";
 import { mangleLocal } from "../mangle.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
+import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
+import { widenInteger } from "./integer-values.js";
 import { SCALAR_UNION_RESULT } from "./int32-abi.js";
 import { emitLiteralSwitch } from "./switch-dispatch.js";
 import { SPECULATIVE_RANGE, emitSafeIntegerCheck, emitSpeculativeInteger, planProvenIntegerLoop, planSpeculativeLoop, speculativeReads, speculativeWriteTarget, } from "./speculative-integers.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
 import { emitStringInputs } from "./string-lifetimes.js";
+import { LOOPS } from "./loop-state.js";
+/** A callback loop version copies the loop; keep the copies small. */
+const MAX_CALLBACK_VERSION_COST = 400;
 export function emitStmtBody(emitter, s) {
     const B = emitter.B;
     emitter.frames.push([]);
@@ -216,6 +224,7 @@ export function emitStmtBody(emitter, s) {
                 emitter.toFrame(v);
             B.line(`store ${emitter.llType(b.type)} ${v.name}, ptr ${b.slot}`);
             emitter.storeIntegerView(s.localId, v, s.init);
+            storeIntegerTemp(emitter, s.localId, b, v);
             if (isRefCounted(b.type)) {
                 emitter.scopes[emitter.scopes.length - 1].push({ slot: b.slot, type: b.type });
                 emitter.noteLastUseMove(s, b);
@@ -357,11 +366,26 @@ export function emitStmtBody(emitter, s) {
             const v = emitter.emitExpr(s.value);
             if (s.arr.type.kind !== "array")
                 throw new InternalCompilerError("llvm emitter bug: arraySet on non-array");
-            const acc = elemAccess(s.arr.type.elem);
+            if (emitter.checkedInt32Array(s.arr)) {
+                // An int32 array with checked stores: the int32 arm stores an int32
+                // value, and widens the array for any other first.
+                emitter.emitPublishedArrayGuard(arr.name, s.arr.type, 0, idx.name);
+                const elem = s.arr.type.elem;
+                const proven = emitter.provenDenseIndex(s.arr, s.index);
+                emitter.emitByElementKind(arr.name, null, (acc, widened) => {
+                    if (acc === "i32")
+                        emitter.emitCheckedInt32Store(arr.name, v.name, s.value, widened);
+                    emitDenseArraySet(emitter, arr.name, idx, s.index, acc, elem, v.name, proven);
+                    return null;
+                });
+                break;
+            }
+            const acc = emitter.arrayAccess(s.arr, s.arr.type.elem);
+            const int32 = emitter.emitInt32KindStoreCheck(s.arr, v, s.value);
             emitter.emitPublishedArrayGuard(arr.name, s.arr.type, 0, idx.name);
             if (acc === "ref")
                 emitter.toHeap(v);
-            emitDenseArraySet(emitter, arr.name, idx, s.index, acc, s.arr.type.elem, v.name, emitter.provenDenseIndex(s.arr, s.index));
+            emitDenseArraySet(emitter, arr.name, idx, s.index, acc, s.arr.type.elem, v.name, emitter.provenDenseIndex(s.arr, s.index), int32);
             break;
         }
         case "arraySetLength": {
@@ -376,6 +400,11 @@ export function emitStmtBody(emitter, s) {
             const length = emitter.emitExpr(s.length);
             if (s.arr.type.kind !== "array")
                 throw new InternalCompilerError("llvm emitter bug: arraySetLength on non-array");
+            if (s.reserve === true) {
+                emitter.declare(`declare void @scr_arr_reserve_len(ptr, double)`);
+                B.line(`call void @scr_arr_reserve_len(ptr ${arr.name}, double ${length.name})`);
+                break;
+            }
             emitter.emitPublishedArrayGuard(arr.name, s.arr.type, s.pop === true ? 2 : 3);
             emitter.declare(`declare void @scr_arr_set_len(ptr, double)`);
             // Assigning the current length (a reused work array reset to where
@@ -401,12 +430,20 @@ export function emitStmtBody(emitter, s) {
                 B.condBr(dropsLast, pop, call);
                 B.startBlock(pop);
                 const elem = s.arr.type.elem;
-                const acc = elemAccess(elem);
-                const raw = emitDenseArrayPop(emitter, arr.name, acc, call, call);
-                if (acc === "ref" && isRefCounted(elem)) {
-                    const old = B.tmp();
-                    B.line(`${old} = inttoptr i64 ${raw} to ptr`);
-                    emitter.releaseHeap(old, elem);
+                if (emitter.checkedInt32Array(s.arr)) {
+                    emitter.emitByElementKind(arr.name, null, (acc) => {
+                        emitDenseArrayPop(emitter, arr.name, acc, elem, call, call);
+                        return null;
+                    });
+                }
+                else {
+                    const acc = emitter.arrayAccess(s.arr, elem);
+                    const raw = emitDenseArrayPop(emitter, arr.name, acc, elem, call, call);
+                    if (acc === "ref" && isRefCounted(elem)) {
+                        const old = B.tmp();
+                        B.line(`${old} = inttoptr i64 ${raw} to ptr`);
+                        emitter.releaseHeap(old, elem);
+                    }
                 }
                 B.br(done);
                 B.startBlock(call);
@@ -443,7 +480,7 @@ export function emitStmtBody(emitter, s) {
             const v = emitter.emitExpr(s.value);
             if (s.arr.type.kind !== "bytes")
                 throw new InternalCompilerError("llvm emitter bug: bytesSet on non-bytes");
-            emitter.emitBytesSet(s.arr.type.elem, arr.name, idx, v, s.index, s.value, emitter.bytesBounds.has(s));
+            emitter.emitBytesSet(s.arr.type.elem, arr.name, idx, v, s.index, s.value, emitter.bytesBounds.has(s), emitter.bytesOwned.has(s));
             break;
         }
         case "fieldSet":
@@ -481,13 +518,10 @@ export function emitStmtBody(emitter, s) {
             else if (emitter.publishedTypes?.recordGuarded(s.shapeId) === true)
                 emitter.emitPublishedFieldGuard(obj.name, null, s.field);
             const { ptr, type, inline } = s.kind === "fieldSet"
-                ? emitter.classFieldPtr(obj.name, s.className, s.field)
+                ? emitter.classFieldPtr(obj.name, s.className, s.field, "compressed")
                 : emitter.recordFieldPtr(obj.name, s.shapeId, s.field);
             // A result-slot entry fills zeroed caller storage, each field once.
-            if (s.kind === "recordSet" &&
-                s.obj.kind === "varRef" &&
-                s.obj.localId === RESULT_DST_ID &&
-                emitter.currentFunctionName.startsWith(RESULT_ENTRY_PREFIX))
+            if (resultSlotStore(emitter.currentFunctionName, s))
                 emitter.initField(ptr, type, inline, v);
             else
                 emitter.replaceField(ptr, type, inline, v);
@@ -691,7 +725,12 @@ export function emitStmtBody(emitter, s) {
             const trueLabel = B.newLabel("if.t");
             const joinLabel = B.newLabel("if.j");
             const falseLabel = s.else_ ? B.newLabel("if.f") : joinLabel;
-            B.condBr(cond, trueLabel, falseLabel);
+            // A running maximum or minimum is rarely updated; the weights keep
+            // the branch, where a select would make each element wait on the last.
+            const weights = emitter.runningExtrema.has(s)
+                ? `, !prof !{!"branch_weights", i32 1, i32 1000}`
+                : "";
+            B.condBr(cond, trueLabel, falseLabel, weights);
             B.startBlock(trueLabel);
             emitter.emitBlock(s.then);
             B.br(joinLabel);
@@ -704,6 +743,20 @@ export function emitStmtBody(emitter, s) {
             break;
         }
         case "while": {
+            const callbacks = callbackVersionBindings(emitter, s);
+            if (callbacks) {
+                emitCallbackVersionedLoop(emitter, s, callbacks);
+                break;
+            }
+            const version = LOOPS.of(emitter).bytesLoopVersionsEnabled &&
+                LOOPS.of(emitter).bytesLoopVersioning.size < MAX_BYTES_LOOP_VERSION_DEPTH &&
+                !LOOPS.of(emitter).bytesLoopVersioning.has(s)
+                ? emitter.matchBytesLoopVersion(s, null)
+                : null;
+            if (version) {
+                emitVersionedLoop(emitter, s, version);
+                break;
+            }
             const workerBudget = emitter.workerLoopBudget(s);
             const le = B.newLabel("loop.e");
             emitter.emitLoopCopies(s, true, le, (exit) => {
@@ -712,6 +765,7 @@ export function emitStmtBody(emitter, s) {
                 const lp = workerBudget !== null ? B.newLabel("loop.p") : lc;
                 B.br(lc);
                 B.startBlock(lc);
+                enterLoopHeader(emitter, lc);
                 B.condBr(emitter.emitCondition(s.cond), lb, exit);
                 B.startBlock(lb);
                 emitter.jumpTargets.push({
@@ -736,6 +790,11 @@ export function emitStmtBody(emitter, s) {
             break;
         }
         case "doWhile": {
+            const callbacks = callbackVersionBindings(emitter, s);
+            if (callbacks) {
+                emitCallbackVersionedLoop(emitter, s, callbacks);
+                break;
+            }
             const workerBudget = emitter.workerLoopBudget(s);
             // Body first (runs at least once); continue jumps to the CONDITION.
             const le = B.newLabel("loop.e");
@@ -744,6 +803,7 @@ export function emitStmtBody(emitter, s) {
                 const lc = B.newLabel("loop.c");
                 B.br(lb);
                 B.startBlock(lb);
+                enterLoopHeader(emitter, lb);
                 emitter.jumpTargets.push({
                     kind: "loop",
                     brkLabel: exit,
@@ -764,6 +824,11 @@ export function emitStmtBody(emitter, s) {
             break;
         }
         case "for": {
+            const callbacks = callbackVersionBindings(emitter, s);
+            if (callbacks) {
+                emitCallbackVersionedLoop(emitter, s, callbacks);
+                break;
+            }
             // The init's scope wraps the whole loop (break/continue must NOT
             // release it — scopeDepth captured after the push, C parity).
             const integerArrayLoop = emitter.debug === null
@@ -771,13 +836,19 @@ export function emitStmtBody(emitter, s) {
                 : null;
             const integerLoop = integerArrayLoop ??
                 (emitter.debug === null ? matchIntegerBytesForLoop(s, emitter.numericLocals) : null);
-            const countedLoop = !integerLoop && emitter.countedLoopsEnabled
-                ? matchIntegerCountedForLoop(s, emitter.numericLocals, emitter.integerRanges, emitter.unaliasedArrays)
+            const countedLoop = !integerLoop && LOOPS.of(emitter).countedLoopsEnabled
+                ? matchIntegerCountedForLoop(s, emitter.numericLocals, emitter.integerRanges, LOOPS.of(emitter).unaliasedArrays)
                 : null;
-            const window = countedLoop && emitter.byteWindowsEnabled
-                ? matchByteWindow(s, countedLoop, emitter.numericLocals, emitter.captureIds, emitter.integerRanges, emitter.byteWindowEntries.get(s) ?? new Set())
+            // Two counters closing in on each other (`lo++, hi--`) take the same
+            // integer storage as a counted loop's one.
+            const pairedLoop = !integerLoop && !countedLoop && LOOPS.of(emitter).countedLoopsEnabled
+                ? matchIntegerPairedForLoop(s, emitter.numericLocals, emitter.integerRanges)
                 : null;
-            const denseShape = !emitter.denseLoopsEnabled
+            // Byte windows and dense loops reason about one counter.
+            const window = countedLoop && countedLoop.followers.length === 0 && LOOPS.of(emitter).byteWindowsEnabled
+                ? matchByteWindow(s, countedLoop, emitter.numericLocals, emitter.captureIds, emitter.integerRanges, LOOPS.of(emitter).byteWindowEntries.get(s) ?? new Set())
+                : null;
+            const denseShape = !LOOPS.of(emitter).denseLoopsEnabled
                 ? null
                 : integerArrayLoop
                     ? {
@@ -785,29 +856,31 @@ export function emitStmtBody(emitter, s) {
                         length: integerArrayLoop.limitReceiver,
                         range: { min: 0, max: 4294967294 },
                     }
-                    : countedLoop && !countedLoop.guarded
+                    : countedLoop && !countedLoop.guarded && countedLoop.followers.length === 0
                         ? countedDenseShape(s, countedLoop)
-                        : null;
+                        : pairedLoop
+                            ? pairedDenseShape(pairedLoop)
+                            : null;
             const dense = denseShape && !window
-                ? matchDenseArrayLoop(s, denseShape, emitter.numericLocals, emitter.unaliasedArrays, emitter.denseLoopEntries.get(s) ?? new Set())
+                ? matchDenseArrayLoop(s, denseShape, emitter.numericLocals, LOOPS.of(emitter).unaliasedArrays, LOOPS.of(emitter).denseLoopEntries.get(s) ?? new Set())
                 : null;
             if (dense) {
                 const valid = emitDenseLoopGuard(emitter, dense);
                 const fast = B.newLabel("dense.loop.fast"), slow = B.newLabel("dense.loop.slow"), done = B.newLabel("dense.loop.done");
                 B.condBr(valid, fast, slow);
-                emitter.denseLoopsEnabled = false;
+                LOOPS.of(emitter).denseLoopsEnabled = false;
                 try {
                     B.startBlock(slow);
                     emitter.emitStmt(s);
                     B.br(done);
                     B.startBlock(fast);
-                    emitter.denseLoop = dense;
+                    LOOPS.of(emitter).denseLoop = dense;
                     emitter.emitStmt(s);
                     B.br(done);
                 }
                 finally {
-                    emitter.denseLoop = null;
-                    emitter.denseLoopsEnabled = true;
+                    LOOPS.of(emitter).denseLoop = null;
+                    LOOPS.of(emitter).denseLoopsEnabled = true;
                 }
                 B.startBlock(done);
                 break;
@@ -817,7 +890,7 @@ export function emitStmtBody(emitter, s) {
                 const fast = B.newLabel("bytes.window.fast"), slow = B.newLabel("bytes.window.slow"), done = B.newLabel("bytes.window.done");
                 B.condBr(valid, fast, slow);
                 const originalRanges = emitter.integerRanges, originalBounds = emitter.bytesBounds;
-                emitter.byteWindowsEnabled = false;
+                LOOPS.of(emitter).byteWindowsEnabled = false;
                 try {
                     B.startBlock(slow);
                     emitter.emitStmt(s);
@@ -831,60 +904,51 @@ export function emitStmtBody(emitter, s) {
                 finally {
                     emitter.integerRanges = originalRanges;
                     emitter.bytesBounds = originalBounds;
-                    emitter.byteWindowsEnabled = true;
+                    LOOPS.of(emitter).byteWindowsEnabled = true;
                 }
                 B.startBlock(done);
                 break;
             }
-            const version = emitter.bytesLoopVersionsEnabled &&
-                emitter.bytesLoopVersioning.size < MAX_BYTES_LOOP_VERSION_DEPTH &&
-                !emitter.bytesLoopVersioning.has(s)
-                ? emitter.matchBytesLoopVersion(s, countedLoop)
+            const versionable = LOOPS.of(emitter).bytesLoopVersionsEnabled &&
+                LOOPS.of(emitter).bytesLoopVersioning.size < MAX_BYTES_LOOP_VERSION_DEPTH &&
+                !LOOPS.of(emitter).bytesLoopVersioning.has(s);
+            // A loop to a typed array's or an array's length keeps its integer
+            // induction. Its counted form only gives the version guard the
+            // counter's iteration space, so the guard also covers accesses of
+            // other typed arrays at the counter, such as `x[i]` and `y[i]` in
+            // `for (let i = 0; i < out.length; i++) out[i] = x[i] * y[i]`.
+            const versionCounted = versionable && !countedLoop && integerLoop && LOOPS.of(emitter).countedLoopsEnabled
+                ? matchIntegerCountedForLoop(s, emitter.numericLocals, emitter.integerRanges, LOOPS.of(emitter).unaliasedArrays)
+                : countedLoop;
+            const version = versionable
+                ? emitter.matchBytesLoopVersion(s, versionCounted, versionCounted ? null : pairedLoop)
                 : null;
             if (version) {
-                const fast = B.newLabel("bytes.version.fast"), slow = B.newLabel("bytes.version.slow"), done = B.newLabel("bytes.version.done");
-                emitBytesLoopVersionGuard(emitter, version, fast, slow);
-                const originalBounds = emitter.bytesBounds, originalRanges = emitter.integerRanges;
-                emitter.bytesLoopVersioning.add(s);
-                try {
-                    B.startBlock(slow);
-                    emitter.emitStmt(s);
-                    B.br(done);
-                    B.startBlock(fast);
-                    emitter.bytesBounds = new Set([...originalBounds, ...version.bounds]);
-                    if (version.ranges.size > 0)
-                        emitter.integerRanges = new Map([...originalRanges, ...version.ranges]);
-                    if (version.counted?.guarded)
-                        emitter.provenCountedGuards.add(s);
-                    emitter.emitStmt(s);
-                    B.br(done);
-                }
-                finally {
-                    emitter.bytesBounds = originalBounds;
-                    emitter.integerRanges = originalRanges;
-                    emitter.provenCountedGuards.delete(s);
-                    emitter.bytesLoopVersioning.delete(s);
-                }
-                B.startBlock(done);
+                emitVersionedLoop(emitter, s, version);
                 break;
             }
             let countedJoin = null;
-            if (countedLoop?.guarded && !emitter.provenCountedGuards.has(s)) {
-                const safe = emitCountedLoopSafety(emitter, countedLoop);
+            if ((countedLoop?.guarded || pairedLoop?.guarded) &&
+                !LOOPS.of(emitter).provenCountedGuards.has(s)) {
+                const safe = countedLoop
+                    ? emitCountedLoopSafety(emitter, countedLoop)
+                    : emitPairedLoopSafety(emitter, pairedLoop);
                 const fast = B.newLabel("counted.fast");
                 const slow = B.newLabel("counted.slow");
                 countedJoin = B.newLabel("counted.done");
                 B.condBr(safe, fast, slow);
                 B.startBlock(slow);
-                emitter.countedLoopsEnabled = false;
+                LOOPS.of(emitter).countedLoopsEnabled = false;
                 emitter.emitStmt(s);
-                emitter.countedLoopsEnabled = true;
+                LOOPS.of(emitter).countedLoopsEnabled = true;
                 B.br(countedJoin);
                 B.startBlock(fast);
             }
             emitter.scopes.push([]);
             let integerSlot = null;
             let countedLimit = null;
+            const pairedSlots = [];
+            const followerSlots = [];
             if (integerLoop) {
                 integerSlot = B.slot();
                 B.entryAllocas.push(`${integerSlot} = alloca ${emitter.sizeType} ; integer induction ${emitter.currentLocals.get(integerLoop.localId).name}`);
@@ -903,8 +967,8 @@ export function emitStmtBody(emitter, s) {
                 emitter.integerLoopBindings.set(integerLoop.localId, {
                     slot: integerSlot,
                     type: emitter.sizeType,
-                    range: emitter.denseLoop?.counter === integerLoop.localId
-                        ? emitter.denseLoop.range
+                    range: LOOPS.of(emitter).denseLoop?.counter === integerLoop.localId
+                        ? LOOPS.of(emitter).denseLoop.range
                         : { min: 0, max: integerArrayLoop ? 4294967294 : Number.MAX_SAFE_INTEGER - 1 },
                 });
             }
@@ -919,12 +983,47 @@ export function emitStmtBody(emitter, s) {
                     slot: integerSlot,
                     type: "i64",
                     signed: true,
-                    range: emitter.denseLoop?.counter === countedLoop.localId
-                        ? emitter.denseLoop.range
+                    range: LOOPS.of(emitter).denseLoop?.counter === countedLoop.localId
+                        ? LOOPS.of(emitter).denseLoop.range
                         : countedLoop.range,
                 });
+                for (const follower of countedLoop.followers) {
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca i64 ; integer induction ${emitter.currentLocals.get(follower.localId).name}`);
+                    const value = emitter.emitExpr(follower.start);
+                    const followerStart = B.tmp();
+                    B.line(`${followerStart} = fptosi double ${value.name} to i64`);
+                    B.line(`store i64 ${followerStart}, ptr ${slot}`);
+                    followerSlots.push(slot);
+                    emitter.integerLoopBindings.set(follower.localId, {
+                        slot,
+                        type: "i64",
+                        signed: true,
+                        range: follower.range,
+                    });
+                }
                 countedLimit = emitCountedLoopLimit(emitter, countedLoop);
             }
+            else if (pairedLoop) {
+                for (const counter of [pairedLoop.low, pairedLoop.high]) {
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca i64 ; integer induction ${emitter.currentLocals.get(counter.localId).name}`);
+                    const value = emitter.emitExpr(counter.start);
+                    const start = B.tmp();
+                    B.line(`${start} = fptosi double ${value.name} to i64`);
+                    B.line(`store i64 ${start}, ptr ${slot}`);
+                    pairedSlots.push(slot);
+                    const dense = LOOPS.of(emitter).denseLoop;
+                    emitter.integerLoopBindings.set(counter.localId, {
+                        slot,
+                        type: "i64",
+                        signed: true,
+                        range: dense?.pair && dense.counter === pairedLoop.low.localId
+                            ? dense.range
+                            : pairedLoop.range,
+                    });
+                }
+            }
             else if (s.init) {
                 // A multi-declarator head shares the loop's scope. Emitting its
                 // IR block as an ordinary block would release captured/ref locals
@@ -966,6 +1065,7 @@ export function emitStmtBody(emitter, s) {
                 const lu = s.update || capturedLets.length > 0 || workerBudget !== null ? B.newLabel("loop.u") : lc;
                 B.br(lc);
                 B.startBlock(lc);
+                enterLoopHeader(emitter, lc);
                 if (integerLoop && integerSlot) {
                     const receiver = emitter.emitStableReceiver(integerLoop.limitReceiver, []);
                     const lenPtr = B.tmp();
@@ -988,8 +1088,7 @@ export function emitStmtBody(emitter, s) {
                         B.line(`${inBounds} = icmp ult i32 ${narrow}, ${len}`);
                     }
                     else {
-                        emitter.markMemoryPointer(lenPtr, "bytes:header");
-                        B.line(`${len} = load ${emitter.sizeType}, ptr ${lenPtr}${emitter.fieldAliasAttachment(lenPtr)}`);
+                        B.line(`${len} = load ${emitter.sizeType}, ptr ${lenPtr}${bytesHeaderAlias(emitter)}`);
                         B.line(`${inBounds} = icmp ult ${emitter.sizeType} ${index}, ${len}`);
                     }
                     B.condBr(inBounds, lb, exit);
@@ -1001,6 +1100,13 @@ export function emitStmtBody(emitter, s) {
                     B.line(`${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`);
                     B.condBr(inBounds, lb, exit);
                 }
+                else if (pairedLoop) {
+                    const low = B.tmp(), high = B.tmp(), open = B.tmp();
+                    B.line(`${low} = load i64, ptr ${pairedSlots[0]}`);
+                    B.line(`${high} = load i64, ptr ${pairedSlots[1]}`);
+                    B.line(`${open} = icmp ${pairedLoop.inclusive ? "sle" : "slt"} i64 ${low}, ${high}`);
+                    B.condBr(open, lb, exit);
+                }
                 else if (s.cond)
                     B.condBr(emitter.emitCondition(s.cond), lb, exit);
                 else
@@ -1035,6 +1141,22 @@ export function emitStmtBody(emitter, s) {
                         B.line(`${old} = load i64, ptr ${integerSlot}`);
                         B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`);
                         B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                        countedLoop.followers.forEach((follower, i) => {
+                            const was = B.tmp();
+                            const now = B.tmp();
+                            B.line(`${was} = load i64, ptr ${followerSlots[i]}`);
+                            B.line(`${now} = add nsw i64 ${was}, ${follower.step}`);
+                            B.line(`store i64 ${now}, ptr ${followerSlots[i]}`);
+                        });
+                    }
+                    else if (pairedLoop) {
+                        [pairedLoop.low, pairedLoop.high].forEach((counter, i) => {
+                            const old = B.tmp();
+                            const next = B.tmp();
+                            B.line(`${old} = load i64, ptr ${pairedSlots[i]}`);
+                            B.line(`${next} = add nsw i64 ${old}, ${counter.step}`);
+                            B.line(`store i64 ${next}, ptr ${pairedSlots[i]}`);
+                        });
                     }
                     else if (s.update)
                         emitter.emitStmt(s.update);
@@ -1045,8 +1167,15 @@ export function emitStmtBody(emitter, s) {
             emitter.releaseScope(emitter.scopes.pop());
             if (integerLoop)
                 emitter.integerLoopBindings.delete(integerLoop.localId);
-            if (countedLoop)
+            if (countedLoop) {
                 emitter.integerLoopBindings.delete(countedLoop.localId);
+                for (const follower of countedLoop.followers)
+                    emitter.integerLoopBindings.delete(follower.localId);
+            }
+            if (pairedLoop) {
+                emitter.integerLoopBindings.delete(pairedLoop.low.localId);
+                emitter.integerLoopBindings.delete(pairedLoop.high.localId);
+            }
             if (integerArrayLoop)
                 emitter.integerArrayBindings.delete(integerArrayLoop.localId);
             if (countedJoin) {
@@ -1416,6 +1545,40 @@ export function emitStmtBody(emitter, s) {
  * Abrupt completions inside tryBody/catchBody ride the finallyStack:
  * returns inline copies at the return site, while break/continue use the
  * shared region walk before branching to their resolved target. */
+/** A constant number local whose initializer has an exact integer form
+ * (such as `const j = i * 4` in a typed-array loop version) keeps that
+ * integer in an i64 slot beside the double, so reads such as `px[j + 1]`
+ * index with integer arithmetic instead of converting the double back.
+ * Every other declaration of the local drops the integer: the same
+ * declaration is emitted once per loop copy, and a copy must not read the
+ * integer another copy stored. */
+function storeIntegerTemp(emitter, localId, b, v) {
+    const local = b.local;
+    if (!emitter.integerTempsEnabled ||
+        b.kind !== "local" ||
+        !local ||
+        local.type.kind !== "f64" ||
+        local.mutable ||
+        local.tdz === true ||
+        emitter.captureIds.has(localId) ||
+        !v.integer) {
+        emitter.integerTemps.delete(localId);
+        return;
+    }
+    const B = emitter.B;
+    let slot = emitter.integerTemps.get(localId)?.slot;
+    if (slot === undefined) {
+        slot = B.slot();
+        B.entryAllocas.push(`${slot} = alloca i64 ; integer ${local.name}`);
+    }
+    B.line(`store i64 ${widenInteger(emitter, v.integer)}, ptr ${slot}`);
+    emitter.integerTemps.set(localId, {
+        slot,
+        type: "i64",
+        signed: true,
+        range: v.integer.range,
+    });
+}
 export function emitTryCatch(emitter, s) {
     const B = emitter.B;
     const hasCatch = s.catchBody !== null;
@@ -1562,7 +1725,7 @@ export function emitTryCatch(emitter, s) {
  * case, refcounted/boxed case-body locals are NULL-reset up front and
  * the scope-exit releases rely on NULL tolerance. */
 export function emitSwitch(emitter, s) {
-    const unitSwitch = charAtUnitSwitch(s);
+    const unitSwitch = charAtUnitSwitch(emitter, s);
     if (unitSwitch !== null)
         return emitSwitch(emitter, unitSwitch);
     const B = emitter.B;
@@ -1668,10 +1831,136 @@ export function emitSwitch(emitter, s) {
     B.br(end);
     B.startBlock(end);
 }
+/** The loop copies a callback loop version needs: the bindings the loop
+ * calls that the constant-callback census resolves to one function, each
+ * with that function's direct entry. Only small loops of optimized
+ * synchronous functions, and only bindings declared before the loop,
+ * qualify: the guard reads each binding before the loop runs. Versions do
+ * not nest: a loop inside either copy of a version (including the
+ * versioned loop itself, emitted again for each copy) keeps its calls as
+ * they are, so a loop nest is emitted at most twice. */
+function callbackVersionBindings(emitter, s) {
+    if (!emitter.callbackVersionsEnabled ||
+        emitter.currentConstantCallbacks.size === 0 ||
+        emitter.callbackVersioning.size > 0)
+        return null;
+    const found = new Map();
+    // Bindings the loop declares or writes (a callback declared in its body).
+    const bound = new Set();
+    let cost = 0;
+    const expr = (e) => {
+        if (++cost > MAX_CALLBACK_VERSION_COST)
+            return false;
+        if (e.kind === "assignExpr")
+            bound.add(e.localId);
+        if (e.kind === "callValue" && e.callee.kind === "varRef" && !found.has(e.callee.localId)) {
+            const local = emitter.currentLocals.get(e.callee.localId);
+            const target = local && local.tdz !== true ? emitter.knownCallbackTarget(e.callee) : undefined;
+            if (target)
+                found.set(e.callee.localId, { ref: e.callee, direct: target.direct });
+        }
+        return everyExprChild(e, expr, stmt);
+    };
+    const stmt = (x) => {
+        if (++cost > MAX_CALLBACK_VERSION_COST)
+            return false;
+        if (x.kind === "varDecl" || x.kind === "assign" || x.kind === "forOf")
+            bound.add(x.localId);
+        else if (x.kind === "tryCatch" && x.catchLocalId !== null)
+            bound.add(x.catchLocalId);
+        return everyStmtChild(x, expr, stmt);
+    };
+    if (!stmt(s))
+        return null;
+    const bindings = [...found.values()].filter(({ ref }) => !bound.has(ref.localId));
+    return bindings.length > 0 ? bindings : null;
+}
+/** A callback loop version. The guard tests, once before the loop, that
+ * each binding's closure holds its known function: a closure's code
+ * pointer is written only when the closure is built, and the census
+ * resolves only bindings the function never rebinds. The copy where the
+ * guard holds calls those functions directly, with no indirect fallback
+ * that could rewrite the closure or what it captures, so LLVM can keep a
+ * captured scalar the callback updates in a register. The other copy is the
+ * ordinary loop. */
+function emitCallbackVersionedLoop(emitter, s, bindings) {
+    const B = emitter.B;
+    let ok = "true";
+    for (const { ref, direct } of bindings) {
+        // A borrowed read: the guard only compares the code pointer.
+        const closure = emitter.emitReadReceiver(ref).name;
+        const fnp = B.tmp(), fn = B.tmp(), same = B.tmp();
+        B.line(`${fnp} = getelementptr inbounds %ScrClosure, ptr ${closure}, i64 0, i32 1`);
+        B.line(`${fn} = load ptr, ptr ${fnp}`);
+        B.line(`${same} = icmp eq ptr ${fn}, ${direct}`);
+        if (ok === "true")
+            ok = same;
+        else {
+            const both = B.tmp();
+            B.line(`${both} = and i1 ${ok}, ${same}`);
+            ok = both;
+        }
+    }
+    const fast = B.newLabel("callback.version.fast"), slow = B.newLabel("callback.version.slow"), done = B.newLabel("callback.version.done");
+    B.condBr(ok, fast, slow);
+    emitter.callbackVersioning.add(s);
+    try {
+        B.startBlock(slow);
+        emitter.emitStmt(s);
+        B.br(done);
+        B.startBlock(fast);
+        for (const { ref } of bindings)
+            emitter.knownCallbacks.add(ref.localId);
+        emitter.emitStmt(s);
+        B.br(done);
+    }
+    finally {
+        for (const { ref } of bindings)
+            emitter.knownCallbacks.delete(ref.localId);
+        emitter.callbackVersioning.delete(s);
+    }
+    B.startBlock(done);
+}
+/** Entries in a row whose fast copy bailed before a speculative loop site
+ * stops trying it. */
+const SPECULATION_BAILS = 8;
 /** Emit a loop's condition, body and update through `emitCopy`, twice
  * when speculative-integers.ts plans a fast integer copy. Both copies
  * share the loop's setup and exit; the ordinary copy comes first so the
  * fast copy is only emitted when every resume point exists. */
+/** A typed-array loop version: the guard, then the checked copy, which
+ * runs whenever the guard fails, and the copy whose accesses the guard
+ * proves in bounds (or thread-owned). */
+function emitVersionedLoop(emitter, s, version) {
+    const B = emitter.B;
+    const fast = B.newLabel("bytes.version.fast"), slow = B.newLabel("bytes.version.slow"), done = B.newLabel("bytes.version.done");
+    emitBytesLoopVersionGuard(emitter, version, fast, slow);
+    const originalBounds = emitter.bytesBounds, originalOwned = emitter.bytesOwned, originalRanges = emitter.integerRanges;
+    LOOPS.of(emitter).bytesLoopVersioning.add(s);
+    try {
+        B.startBlock(slow);
+        emitter.emitStmt(s);
+        B.br(done);
+        B.startBlock(fast);
+        emitter.bytesBounds = new Set([...originalBounds, ...version.bounds]);
+        if (version.owned.size > 0)
+            emitter.bytesOwned = new Set([...originalOwned, ...version.owned]);
+        if (version.ranges.size > 0)
+            emitter.integerRanges = new Map([...originalRanges, ...version.ranges]);
+        if (version.counted?.guarded || version.paired?.loop.guarded)
+            LOOPS.of(emitter).provenCountedGuards.add(s);
+        emitter.emitStmt(s);
+        B.br(done);
+    }
+    finally {
+        emitter.bytesBounds = originalBounds;
+        emitter.bytesOwned = originalOwned;
+        emitter.integerRanges = originalRanges;
+        LOOPS.of(emitter).provenCountedGuards.delete(s);
+        LOOPS.of(emitter).bytesLoopVersioning.delete(s);
+    }
+    B.startBlock(done);
+}
 export function emitLoopCopies(emitter, loop, allowed, exit, emitCopy) {
     const plan = allowed &&
         emitter.speculativeLoopsEnabled &&
@@ -1686,11 +1975,25 @@ export function emitLoopCopies(emitter, loop, allowed, exit, emitCopy) {
         }, (id) => emitter.speculativeLocal(id) || emitter.speculativeInvariantGlobal(id))
         : null;
     if (!plan) {
-        const proven = allowed ? planProvenLoop(emitter, loop) : null;
-        if (proven)
-            emitProvenLoop(emitter, proven, exit, emitCopy);
+        const ordinary = (exit) => {
+            const proven = allowed ? planProvenLoop(emitter, loop) : null;
+            if (proven)
+                emitProvenLoop(emitter, proven, exit, emitCopy);
+            else
+                emitCopy(exit);
+        };
+        const kinds = allowed &&
+            emitter.speculativeLoopsEnabled &&
+            emitter.int32Slots.checkedInt32Arrays.size > 0 &&
+            emitter.int32Kinds === null &&
+            emitter.speculation === null &&
+            emitter.speculationResume === null
+            ? planInt32KindLoop(loop, (id) => emitter.checkedInt32Local(id), (e) => withinInt32(emitter.integerRanges.get(e)))
+            : null;
+        if (kinds)
+            emitInt32KindLoop(emitter, kinds, exit, kinds.writes.size > 0 ? emitCopy : ordinary);
         else
-            emitCopy(exit);
+            ordinary(exit);
         return;
     }
     const B = emitter.B;
@@ -1711,24 +2014,67 @@ export function emitLoopCopies(emitter, loop, allowed, exit, emitCopy) {
             ok = both;
         }
     }
+    // Each entry whose fast copy bails counts at the loop site, and a fast
+    // copy that completes a speculated write and leaves the loop clears the
+    // count. After SPECULATION_BAILS bailing entries in a row, the site runs
+    // the ordinary copy only. The count is a hint: both copies give the same
+    // results, and a race between workers loses at most an update.
+    const bails = emitter.speculativeLoopSite();
+    const count = B.tmp(), trying = B.tmp();
+    B.line(`${count} = load atomic i8, ptr ${bails} unordered, align 1`);
+    B.line(`${trying} = icmp ult i8 ${count}, ${SPECULATION_BAILS}`);
+    if (ok === "true")
+        ok = trying;
+    else {
+        const both = B.tmp();
+        B.line(`${both} = and i1 ${ok}, ${trying}`);
+        ok = both;
+    }
     const fast = B.newLabel("spec.fast"), slow = B.newLabel("spec.slow");
     B.condBr(ok, fast, slow);
     const resume = new Map();
     for (const s of plan.writes)
         resume.set(s, { label: B.newLabel("spec.resume"), placed: false });
+    // A failed check finishes its iteration in a third copy, entered only
+    // there: it re-executes the statement and the rest of the body and the
+    // update, then enters the ordinary copy through its header. Jumping
+    // into the middle of the ordinary copy instead would give that loop a
+    // second entry, and LLVM does not optimize an irreducible loop.
+    const points = [...resume.values()];
+    let header = null;
     B.startBlock(slow);
+    emitter.speculationHeader = (label) => {
+        header = label;
+    };
+    try {
+        emitCopy(exit);
+    }
+    finally {
+        emitter.speculationHeader = null;
+    }
+    if (header === null)
+        throw new InternalCompilerError("llvm emitter bug: speculative loop copy without a header");
+    B.startBlock(B.newLabel("spec.tail"));
     emitter.speculationResume = resume;
+    emitter.speculationHeader = () => {
+        B.br(header);
+        B.startBlock(B.newLabel("spec.unused"));
+    };
     try {
         emitCopy(exit);
     }
     finally {
         emitter.speculationResume = null;
+        emitter.speculationHeader = null;
     }
     B.startBlock(fast);
-    if (![...resume.values()].every((r) => r.placed)) {
+    if (!points.every((r) => r.placed)) {
         B.br(slow);
         return;
     }
+    const ran = B.slot();
+    B.entryAllocas.push(`${ran} = alloca i1 ; speculated write completed`);
+    B.line(`store i1 false, ptr ${ran}`);
     for (const id of plan.locals.keys()) {
         const shadow = B.slot();
         B.entryAllocas.push(`${shadow} = alloca i64 ; speculative integer ${emitter.currentLocals.get(id)?.name ?? id}`);
@@ -1766,17 +2112,25 @@ export function emitLoopCopies(emitter, loop, allowed, exit, emitCopy) {
         writes: plan.writes,
         resume: new Map([...resume].map(([s, r]) => [s, r.label])),
         deferred,
+        bails,
+        ran,
     };
     try {
-        if (deferred.size === 0)
-            emitCopy(exit);
-        else {
-            const leave = B.newLabel("spec.leave");
-            emitCopy(leave);
-            B.startBlock(leave);
-            emitter.writeBackDeferred(deferred);
-            B.br(exit);
-        }
+        const leave = B.newLabel("spec.leave");
+        emitCopy(leave);
+        B.startBlock(leave);
+        emitter.writeBackDeferred(deferred);
+        // An entry that never ran a speculated write (a loop of no iterations)
+        // says nothing about the site.
+        const wrote = B.tmp(), left = B.tmp(), counted = B.tmp(), both = B.tmp(), clear = B.newLabel("spec.clear");
+        B.line(`${wrote} = load i1, ptr ${ran}`);
+        B.line(`${left} = load atomic i8, ptr ${bails} unordered, align 1`);
+        B.line(`${counted} = icmp ne i8 ${left}, 0`);
+        B.line(`${both} = and i1 ${wrote}, ${counted}`);
+        B.condBr(both, clear, exit);
+        B.startBlock(clear);
+        B.line(`store atomic i8 0, ptr ${bails} unordered, align 1`);
+        B.br(exit);
     }
     finally {
         emitter.speculation = null;
@@ -1784,6 +2138,127 @@ export function emitLoopCopies(emitter, loop, allowed, exit, emitCopy) {
             emitter.integerLoopBindings.delete(id);
     }
 }
+/** An int32 kind loop (int32-kind-loops.ts). The entry test reads the kind
+ * of each of the plan's arrays: when every one holds int32 slots the fast
+ * copy runs, when every one holds doubles the wide copy, which reads and
+ * writes them as double arrays, and otherwise (a plan with several arrays)
+ * the mixed copy, which tests their kinds at each access. A failed store of
+ * the fast copy re-executes in the third copy, which finishes its
+ * iteration with kind tests and then enters the mixed copy, or the wide
+ * copy when the plan has one array (it just widened). Each copy is emitted
+ * by `ordinary`: the loop's plain copy when a store may fail, since a
+ * proven integer loop keeps locals in shadows of its own copy that another
+ * copy cannot resume from. */
+function emitInt32KindLoop(emitter, plan, exit, ordinary) {
+    const B = emitter.B;
+    const fn = emitter.currentFunctionName;
+    const keys = new Set([...plan.arrays.keys()].map((id) => `${fn}\0${id}`));
+    const several = keys.size > 1;
+    let allInt32 = "true", allWide = "true";
+    const and = (all, next) => {
+        if (all === "true")
+            return next;
+        const both = B.tmp();
+        B.line(`${both} = and i1 ${all}, ${next}`);
+        return both;
+    };
+    for (const ref of plan.arrays.values()) {
+        const arr = emitter.emitStableReceiver(ref, []);
+        const kindPtr = B.tmp(), kind = B.tmp(), isInt32 = B.tmp();
+        B.line(`${kindPtr} = getelementptr inbounds %ScrArr, ptr ${arr.name}, i32 0, i32 ${SCR_ARR_FIELD.elem}`);
+        emitter.markMemoryPointer(kindPtr, "array:header");
+        B.line(`${kind} = load i8, ptr ${kindPtr}${emitter.fieldAliasAttachment(kindPtr)}`);
+        B.line(`${isInt32} = icmp eq i8 ${kind}, ${SCR_ELEM_I32}`);
+        allInt32 = and(allInt32, isInt32);
+        if (several) {
+            const isWide = B.tmp();
+            B.line(`${isWide} = xor i1 ${isInt32}, true`);
+            allWide = and(allWide, isWide);
+        }
+    }
+    const fast = B.newLabel("kind.fast"), wide = B.newLabel("kind.wide"), mixed = several ? B.newLabel("kind.mixed") : null;
+    if (mixed === null)
+        B.condBr(allInt32, fast, wide);
+    else {
+        const other = B.newLabel("kind.other");
+        B.condBr(allInt32, fast, other);
+        B.startBlock(other);
+        B.condBr(allWide, wide, mixed);
+    }
+    const resume = new Map();
+    for (const s of plan.writes)
+        resume.set(s, { label: B.newLabel("kind.resume"), placed: false });
+    // The header the third copy enters: the mixed copy's, or the wide copy's.
+    let header = null;
+    const capture = (label) => {
+        header = label;
+    };
+    B.startBlock(wide);
+    if (resume.size > 0 && mixed === null)
+        emitter.speculationHeader = capture;
+    emitter.int32Kinds = { int32: new Set(), wide: keys, resume: new Map() };
+    try {
+        ordinary(exit);
+    }
+    finally {
+        emitter.speculationHeader = null;
+        emitter.int32Kinds = null;
+    }
+    if (mixed !== null) {
+        B.startBlock(mixed);
+        if (resume.size > 0)
+            emitter.speculationHeader = capture;
+        try {
+            ordinary(exit);
+        }
+        finally {
+            emitter.speculationHeader = null;
+        }
+    }
+    if (resume.size > 0) {
+        if (header === null)
+            throw new InternalCompilerError("llvm emitter bug: int32 kind loop copy without a header");
+        // A failed store finishes its iteration here, as in a speculative
+        // integer loop's third copy.
+        B.startBlock(B.newLabel("kind.tail"));
+        emitter.speculationResume = resume;
+        emitter.speculationHeader = () => {
+            B.br(header);
+            B.startBlock(B.newLabel("kind.unused"));
+        };
+        try {
+            ordinary(exit);
+        }
+        finally {
+            emitter.speculationResume = null;
+            emitter.speculationHeader = null;
+        }
+    }
+    B.startBlock(fast);
+    if (![...resume.values()].every((r) => r.placed)) {
+        // A write the third copy never reached: this copy tests the kinds.
+        ordinary(exit);
+        return;
+    }
+    emitter.int32Kinds = {
+        int32: keys,
+        wide: new Set(),
+        resume: new Map([...resume].map(([s, r]) => [s, r.label])),
+    };
+    try {
+        ordinary(exit);
+    }
+    finally {
+        emitter.int32Kinds = null;
+    }
+}
+/** At the top of a loop copy's header: lets a speculative loop find its
+ * ordinary copy's header, and keeps its third copy out of the loop. */
+function enterLoopHeader(emitter, header) {
+    const dispatch = emitter.speculationHeader;
+    emitter.speculationHeader = null;
+    dispatch?.(header);
+}
 /** A proven integer loop (speculative-integers.ts) for this loop, or null.
  * A shadowed local's double is stale until the loop is left, which only
  * the loop's exit, a return and an exception do: the loop is planned only
@@ -1890,7 +2365,9 @@ export function emitSpeculativeWrite(emitter, s, resume) {
     if (emitter.frames.pop().length > 0)
         throw new InternalCompilerError("llvm emitter bug: speculative write owns a temporary");
     B.line(`store i64 ${result}, ptr ${binding.slot}`);
-    const deferred = emitter.speculation.deferred;
+    const { deferred, bails: site, ran } = emitter.speculation;
+    if (ran !== undefined)
+        B.line(`store i1 true, ptr ${ran}`);
     if (!deferred.has(target.localId)) {
         const number = B.tmp();
         B.line(`${number} = sitofp i64 ${result} to double`);
@@ -1902,6 +2379,13 @@ export function emitSpeculativeWrite(emitter, s, resume) {
     B.br(done);
     B.startBlock(failed);
     emitter.writeBackDeferred(deferred);
+    if (site !== undefined) {
+        const count = B.tmp(), next = B.tmp();
+        emitter.declare("declare i8 @llvm.uadd.sat.i8(i8, i8)");
+        B.line(`${count} = load atomic i8, ptr ${site} unordered, align 1`);
+        B.line(`${next} = call i8 @llvm.uadd.sat.i8(i8 ${count}, i8 1)`);
+        B.line(`store atomic i8 ${next}, ptr ${site} unordered, align 1`);
+    }
     B.br(resume);
     B.startBlock(done);
 }
@@ -2019,7 +2503,7 @@ function nullableStringSwitch(emitter, s) {
  * one-unit string literals, as a switch on `s.charCodeAt(i)` with the units
  * as cases: no character string is built. An index out of range answers
  * NaN, which matches no case, as "" matches no one-unit literal. */
-function charAtUnitSwitch(s) {
+function charAtUnitSwitch(emitter, s) {
     const disc = s.disc;
     if (disc.kind !== "strIntrinsic" || disc.method !== "charAt" || disc.args.length !== 1)
         return null;
@@ -2029,7 +2513,7 @@ function charAtUnitSwitch(s) {
         return null;
     return {
         ...s,
-        disc: { ...disc, method: "charCodeAt", type: F64 },
+        disc: charAtUnitRead(emitter, disc),
         cases: s.cases.map((c) => c.test?.kind === "strLit"
             ? {
                 ...c,