@scriptc/compiler 0.2.2 → 0.2.3

package/dist/backend/llvm/emitter.d.ts

@@ -2,7 +2,10 @@ import type { IrBytesElem, IrExpr, IrFfiImport, IrFunction, IrLocal, IrModule, I
 import { type IntegerRanges } from "../../ir/integer-ranges.js";
 import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
+import { type CallLifetimes } from "./call-lifetimes.js";
 import { BlockBuilder } from "./blocks.js";
+import { type LocalArrayRead } from "./local-array-reads.js";
+import { type MapReadLifetimes } from "./map-read-lifetimes.js";
 import { type LlClassMeta } from "./classes.js";
 import { LlDyn, type DynHost } from "./dyn.js";
 import { LlWalkers } from "./walkers.js";
@@ -29,6 +32,19 @@ export declare function emitLlvmModule(mod: IrModule, options?: LlvmTargetOption
 export declare function emitLlvmModuleSource(mod: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare class LlEmitter {
     readonly mod: IrModule;
+    localArrayReads: Map<string, LocalArrayRead>;
+    private localStackUnions;
+    integerArrayBindings: Set<string>;
+    private readonly fieldAliasTags;
+    private readonly fieldPointerTags;
+    /** Native class fields with different property names cannot occupy the
+     * same slot of one object. Inherited views of the same property share a
+     * tag. Array storage has its own disjoint categories; untagged runtime
+     * operations and record views conservatively alias all of them. */
+    private markFieldPointer;
+    markMemoryPointer(ptr: string, field: string): void;
+    fieldAliasAttachment(ptr: string): string;
+    private fieldAliasMetadata;
     private readonly debug;
     private debugScope;
     readonly sizeType: "i32" | "i64";
@@ -84,6 +100,12 @@ export declare class LlEmitter {
     needsBadKey: boolean;
     private needsRetainBox;
     readonly fnByName: Map<string, IrFunction>;
+    private readonly arrayPreservingFunctions;
+    private readonly optionalArrayReads;
+    callArrayReads: Map<IrExpr, LocalArrayRead>;
+    mapReadLifetimes: MapReadLifetimes;
+    readonly callLifetimes: CallLifetimes;
+    private borrowedParameters;
     /** Manifest-bound native imports, used by ffiCall emission. */
     readonly ffiByName: Map<string, IrFfiImport>;
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
@@ -412,6 +434,16 @@ export declare class LlEmitter {
     /** Move a clean async return value into the current fiber's promise. */
     private emitWasiFulfill;
     private emitFunction;
+    /** Keep the ordinary owned ABI for closures, virtual dispatch, generated
+     * runtime adapters and library exports. Only direct IR calls select the
+     * borrowing body. Ownership of other parameters moves into that body;
+     * borrowed parameters are released here on normal and exceptional exits.
+     * The pending exception remains for the adapter's caller to handle. */
+    private emitOwnedCallAdapter;
+    /** A local immutable binding keeps its value alive while later arguments
+     * and the callee execute. Global, captured, TDZ and mutable bindings need
+     * an owned snapshot, even when the callee only inspects the value. */
+    canBorrowCallArgument(value: IrExpr): boolean;
     private emitStmts;
     /** Emits a block in its own lexical scope (refcounted locals released at
      * end). `setup` runs after the
@@ -487,6 +519,7 @@ export declare class LlEmitter {
      * their ordinary statement-frame ownership. The caller must retain any
      * reference result before evaluating another expression. */
     emitReadReceiver(e: IrExpr): LlValue;
+    canBorrowReceiver(e: IrExpr): boolean;
     emitExpr(e: IrExpr): LlValue;
     emitJsMarshal(e: IrExpr & {
         kind: "jsMarshal";

package/dist/backend/llvm/emitter.js

@@ -22,7 +22,7 @@ import { deflateRawSync } from "node:zlib";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
 import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID } from "../../ir/ir.js";
-import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
+import { matchIntegerArrayForLoop, matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
 import { everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
@@ -30,8 +30,13 @@ import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
 import { computeMayThrow } from "../may-throw.js";
-import { mangleArgPack, mangleAsyncSpawn, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance } from "../mangle.js";
+import { mangleArgPack, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance } from "../mangle.js";
+import { analyzeCallLifetimes } from "./call-lifetimes.js";
+import { emitStackUnion, findLocalStackUnions } from "./stack-unions.js";
 import { BlockBuilder } from "./blocks.js";
+import { emitLocalArrayRead, findArrayPreservingFunctions, findLocalArrayReads, findCallArrayReads, OptionalArrayReads } from "./local-array-reads.js";
+import { emitStackMapRead, findMapReadLifetimes } from "./map-read-lifetimes.js";
+import { emitBorrowedFieldSequence } from "./borrowed-receivers.js";
 import { LlvmDebugInfo } from "./debug-info.js";
 import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
@@ -101,6 +106,41 @@ function llStrBytes(text) {
 }
 export class LlEmitter {
     mod;
+    localArrayReads = new Map();
+    localStackUnions = new Map();
+    integerArrayBindings = new Set();
+    fieldAliasTags = new Map();
+    fieldPointerTags = new Map();
+    /** Native class fields with different property names cannot occupy the
+     * same slot of one object. Inherited views of the same property share a
+     * tag. Array storage has its own disjoint categories; untagged runtime
+     * operations and record views conservatively alias all of them. */
+    markFieldPointer(ptr, field) {
+        this.markMemoryPointer(ptr, `field:${field}`);
+    }
+    markMemoryPointer(ptr, field) {
+        if (this.debug !== null)
+            return;
+        let tag = this.fieldAliasTags.get(field);
+        if (tag === undefined) {
+            tag = 2 + this.fieldAliasTags.size * 2;
+            this.fieldAliasTags.set(field, tag);
+        }
+        this.fieldPointerTags.set(ptr, tag);
+    }
+    fieldAliasAttachment(ptr) {
+        const tag = this.fieldPointerTags.get(ptr);
+        return tag === undefined ? "" : `, !tbaa !${tag}`;
+    }
+    fieldAliasMetadata() {
+        if (this.fieldAliasTags.size === 0)
+            return [];
+        const lines = ['!0 = !{!"scriptc native fields"}'];
+        for (const tag of this.fieldAliasTags.values()) {
+            lines.push(`!${tag - 1} = !{!"field.${tag}", !0, i64 0}`, `!${tag} = !{!${tag - 1}, !${tag - 1}, i64 0}`);
+        }
+        return lines;
+    }
     debug;
     debugScope = null;
     sizeType;
@@ -149,6 +189,12 @@ export class LlEmitter {
     needsBadKey = false;
     needsRetainBox = false;
     fnByName = new Map();
+    arrayPreservingFunctions;
+    optionalArrayReads;
+    callArrayReads = new Map();
+    mapReadLifetimes = { locals: new Map(), arguments: new Map() };
+    callLifetimes;
+    borrowedParameters = new Set();
     /** Manifest-bound native imports, used by ffiCall emission. */
     ffiByName = new Map();
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
@@ -298,6 +344,9 @@ export class LlEmitter {
         }
         for (const u of mod.unions ?? [])
             this.unionsById.set(u.id, u);
+        this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById);
+        this.arrayPreservingFunctions = findArrayPreservingFunctions(this.fnByName, this.unionsById, this.optionalArrayReads);
+        this.callLifetimes = analyzeCallLifetimes(this.fnByName);
         for (const r of mod.records ?? [])
             this.recordsById.set(r.id, r);
         const traced = computeTraced(mod);
@@ -849,6 +898,7 @@ export class LlEmitter {
             this.declare(`declare void @scr_net_island_install()`);
         if (usesIsland) {
             this.declare(`declare void @scr_island_modules(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
+            this.declare(`declare void @scr_island_entry_module(ptr)`);
             this.declare(`declare i32 @scr_island_exit_code()`);
             if (moduleEmbedsCompressedNpm(this.mod)) {
                 this.declare(`declare void @scr_island_set_inflate(ptr)`);
@@ -1116,6 +1166,7 @@ export class LlEmitter {
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
+        const islandEntryPath = usesIsland ? this.cstr(this.mod.sourceFile) : null;
         for (const [text, c] of this.cstrs) {
             // NUL-terminated byte-array constants for scr_jb_puts and indentation.
             out.push(`@${c.sym} = internal constant [${c.len + 1} x i8] c"${llStrBytes(text)}"`);
@@ -1247,6 +1298,7 @@ export class LlEmitter {
             if (hasNoInlineRecordClone)
                 out.push(`attributes #2 = { noinline sanitize_address }`);
             out.push(``);
+            out.push(...this.fieldAliasMetadata());
             if (this.debug !== null)
                 out.push(this.debug.render());
             return out;
@@ -1260,6 +1312,7 @@ export class LlEmitter {
         // scr_watch.c links only when this line is emitted.
         ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
             ? [
+                `  call void @scr_island_entry_module(ptr ${islandEntryPath})`,
                 ...(moduleEmbedsCompressedNpm(this.mod)
                     ? [`  call void @scr_island_set_inflate(ptr @scr_zlib_inflate_exact)`]
                     : []),
@@ -1359,6 +1412,7 @@ export class LlEmitter {
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
         `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
+        out.push(...this.fieldAliasMetadata());
         if (this.debug !== null)
             out.push(this.debug.render());
         return out;
@@ -2418,7 +2472,7 @@ export class LlEmitter {
      * a retained peek. */
     unionExtract(uName, arm) {
         const B = this.B;
-        if (arm.kind === "f64") {
+        if (arm.kind === "f64" || arm.kind === "procStream") {
             const t = B.tmp();
             this.declare(`declare double @scr_union_get_f64(ptr)`);
             B.line(`${t} = call double @scr_union_get_f64(ptr ${uName})`);
@@ -2438,7 +2492,7 @@ export class LlEmitter {
     unionNewOwned(tag, v) {
         const B = this.B;
         const t = B.tmp();
-        if (v.type.kind === "f64") {
+        if (v.type.kind === "f64" || v.type.kind === "procStream") {
             this.declare(`declare ptr @scr_union_new_f64(i32, double)`);
             B.line(`${t} = call ptr @scr_union_new_f64(i32 ${tag}, double ${v.name})`);
             return t;
@@ -2469,6 +2523,7 @@ export class LlEmitter {
         const { index, type } = classFieldIndex(meta, field);
         const p = this.B.tmp();
         this.B.line(`${p} = getelementptr inbounds %${classStructSym(className)}, ptr ${objName}, i64 0, i32 ${index}`);
+        this.markFieldPointer(p, field);
         return { ptr: p, type };
     }
     /** `o->vt->pre` — the dynamic class's preorder number (borrowed object;
@@ -2559,7 +2614,7 @@ export class LlEmitter {
         const B = this.B;
         const fieldTy = llFieldType(t);
         const raw = B.tmp();
-        B.line(`${raw} = load ${fieldTy}, ptr ${ptr}`);
+        B.line(`${raw} = load ${fieldTy}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
         if (fieldTy !== "i8")
             return raw;
         const b = B.tmp();
@@ -2571,12 +2626,12 @@ export class LlEmitter {
         const B = this.B;
         const fieldTy = llFieldType(t);
         if (fieldTy !== "i8") {
-            B.line(`store ${fieldTy} ${value}, ptr ${ptr}`);
+            B.line(`store ${fieldTy} ${value}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
             return;
         }
         const z = B.tmp();
         B.line(`${z} = zext i1 ${value} to i8`);
-        B.line(`store i8 ${z}, ptr ${ptr}`);
+        B.line(`store i8 ${z}, ptr ${ptr}${this.fieldAliasAttachment(ptr)}`);
     }
     // ── bindings ────────────────────────────────────────────────────────────
     /** A binding's storage: a module global, a plain local slot, or a boxed
@@ -2856,8 +2911,20 @@ export class LlEmitter {
         this.unwindCleanups.clear();
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
+        this.borrowedParameters.clear();
+        const borrowedParameterIndexes = this.callLifetimes.parameters.get(fn.name);
+        if (borrowedParameterIndexes) {
+            for (const index of borrowedParameterIndexes)
+                this.borrowedParameters.add(fn.params[index].localId);
+        }
         this.captureIds = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
         this.integerLoopBindings.clear();
+        this.fieldPointerTags.clear();
+        this.integerArrayBindings.clear();
+        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.arrayPreservingFunctions, this.callLifetimes, this.optionalArrayReads);
+        this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.arrayPreservingFunctions, this.callLifetimes);
+        this.mapReadLifetimes = findMapReadLifetimes(fn, this.unionsById, this.callLifetimes);
+        this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.unionsById);
         this.integerRanges = analyzeIntegerRanges(fn);
         this.chainSlots.clear();
         this.finallyStack = [];
@@ -2949,7 +3016,8 @@ export class LlEmitter {
         // params (callees own their params — callers passed +1). Boxed params
         // allocate the shared binding and move the raw value in.
         const fnScope = [];
-        for (const p of fn.params) {
+        const borrowed = this.callLifetimes.parameters.get(fn.name);
+        for (const [index, p] of fn.params.entries()) {
             const local = this.currentLocals.get(p.localId);
             const slot = `%${mangleLocal(p.localId)}`;
             if (local.boxed) {
@@ -2961,7 +3029,7 @@ export class LlEmitter {
                 continue;
             }
             B.line(`store ${this.llType(p.type)} %p_${mangleLocal(p.localId)}, ptr ${slot}`);
-            if (isRefCounted(p.type))
+            if (isRefCounted(p.type) && !borrowed?.has(index))
                 fnScope.push({ slot, type: p.type });
         }
         this.scopes.push(fnScope);
@@ -3043,7 +3111,38 @@ export class LlEmitter {
         const ret = this.llType(fn.returnType);
         const attrs = coro !== null ? "#1" : FN_ATTRS;
         const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`;
-        return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
+        const symbol = borrowed ? mangleBorrowedFunction(fn.name) : mangleFunction(fn.name);
+        const body = `define internal ${ret} @${symbol}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
+        return borrowed ? body + "\n" + this.emitOwnedCallAdapter(fn, borrowed) : body;
+    }
+    /** Keep the ordinary owned ABI for closures, virtual dispatch, generated
+     * runtime adapters and library exports. Only direct IR calls select the
+     * borrowing body. Ownership of other parameters moves into that body;
+     * borrowed parameters are released here on normal and exceptional exits.
+     * The pending exception remains for the adapter's caller to handle. */
+    emitOwnedCallAdapter(fn, borrowed) {
+        const B = new BlockBuilder();
+        this.B = B;
+        const params = fn.params.map((param, index) => `${this.llType(param.type)} %p${index}`);
+        const ret = this.llType(fn.returnType);
+        const call = `call ${ret} @${mangleBorrowedFunction(fn.name)}(${params.join(", ")})`;
+        B.line(ret === "void" ? call : `%result = ${call}`);
+        for (const index of borrowed)
+            this.releaseValue(`%p${index}`, fn.params[index].type);
+        B.terminate(ret === "void" ? "ret void" : `ret ${ret} %result`);
+        return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${FN_ATTRS} {\n${B.render()}\n}`;
+    }
+    /** A local immutable binding keeps its value alive while later arguments
+     * and the callee execute. Global, captured, TDZ and mutable bindings need
+     * an owned snapshot, even when the callee only inspects the value. */
+    canBorrowCallArgument(value) {
+        if (value.kind === "strLit")
+            return true;
+        if (value.kind !== "varRef")
+            return false;
+        const binding = this.binding(value.localId);
+        return binding.kind === "local" && binding.local !== undefined &&
+            (!binding.local.mutable || this.borrowedParameters.has(value.localId)) && !binding.local.boxed && !binding.local.tdz;
     }
     // ── statements ──────────────────────────────────────────────────────────
     emitStmts(stmts) {
@@ -3087,6 +3186,31 @@ export class LlEmitter {
         switch (s.kind) {
             case "varDecl": {
                 const b = this.binding(s.localId);
+                const localUnion = this.localStackUnions.get(s.localId);
+                if (localUnion) {
+                    const union = emitStackUnion(this, localUnion);
+                    B.line(`store ptr ${union.value.name}, ptr ${b.slot}`);
+                    if (union.payload) {
+                        this.moveTemp(union.payload);
+                        this.scopes[this.scopes.length - 1].push({ slot: union.payloadSlot, type: union.payload.type });
+                    }
+                    break;
+                }
+                const localRead = this.localArrayReads.get(s.localId);
+                if (localRead) {
+                    const owner = emitLocalArrayRead(this, localRead, b.slot);
+                    if (owner)
+                        this.scopes[this.scopes.length - 1].push(owner);
+                    break;
+                }
+                const mapRead = this.mapReadLifetimes.locals.get(s.localId);
+                if (mapRead) {
+                    const result = emitStackMapRead(this, mapRead);
+                    B.line(`store ptr ${result.value.name}, ptr ${b.slot}`);
+                    if (result.owner)
+                        this.scopes[this.scopes.length - 1].push(result.owner);
+                    break;
+                }
                 if (b.kind === "boxed") {
                     // Box FIRST, then evaluate the initializer: a named function
                     // expression's closure captures this box during init evaluation.
@@ -3225,7 +3349,7 @@ export class LlEmitter {
                 // release — a release can trigger a cycle collection, which must
                 // never see a heap edge whose count was already given up).
                 // Classes and records share the struct layout, so one emission.
-                const obj = this.emitExpr(s.obj);
+                const obj = isRefCounted(s.value.type) ? this.emitExpr(s.obj) : this.emitStableReceiver(s.obj, [s.value]);
                 const v = this.emitExpr(s.value);
                 const { ptr, type } = s.kind === "fieldSet"
                     ? this.classFieldPtr(obj.name, s.className, s.field)
@@ -3486,13 +3610,21 @@ export class LlEmitter {
             case "for": {
                 // The init's scope wraps the whole loop (break/continue must NOT
                 // release it — scopeDepth captured after the push, C parity).
-                const integerLoop = this.debug === null ? matchIntegerBytesForLoop(s, this.currentLocals) : null;
+                const integerArrayLoop = this.debug === null ? matchIntegerArrayForLoop(s, this.currentLocals, this.integerArrayBindings) : null;
+                const integerLoop = integerArrayLoop ?? (this.debug === null ? matchIntegerBytesForLoop(s, this.currentLocals) : null);
                 this.scopes.push([]);
                 let integerSlot = null;
                 if (integerLoop) {
                     integerSlot = B.slot();
                     B.entryAllocas.push(`${integerSlot} = alloca ${this.sizeType} ; integer induction ${this.currentLocals.get(integerLoop.localId).name}`);
-                    B.line(`store ${this.sizeType} 0, ptr ${integerSlot}`);
+                    let start = "0";
+                    if (integerArrayLoop && s.init?.kind === "varDecl" && s.init.init) {
+                        const value = this.emitExpr(s.init.init);
+                        start = B.tmp();
+                        B.line(`${start} = fptoui double ${value.name} to ${this.sizeType}`);
+                        this.integerArrayBindings.add(integerLoop.localId);
+                    }
+                    B.line(`store ${this.sizeType} ${start}, ptr ${integerSlot}`);
                     this.integerLoopBindings.set(integerLoop.localId, integerSlot);
                 }
                 else if (s.init) {
@@ -3540,8 +3672,10 @@ export class LlEmitter {
                     const len = B.tmp();
                     const index = B.tmp();
                     const inBounds = B.tmp();
-                    B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver.name}, i64 0, i32 1`);
-                    B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}`);
+                    B.line(`${lenPtr} = getelementptr inbounds %${integerArrayLoop ? "ScrArr" : "ScrBytes"}, ptr ${receiver.name}, i64 0, i32 1`);
+                    if (integerArrayLoop)
+                        this.markMemoryPointer(lenPtr, "array:header");
+                    B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
                     B.line(`${index} = load ${this.sizeType}, ptr ${integerSlot}`);
                     B.line(`${inBounds} = icmp ult ${this.sizeType} ${index}, ${len}`);
                     B.condBr(inBounds, lb, le);
@@ -3581,6 +3715,8 @@ export class LlEmitter {
                 this.releaseScope(this.scopes.pop());
                 if (integerLoop)
                     this.integerLoopBindings.delete(integerLoop.localId);
+                if (integerArrayLoop)
+                    this.integerArrayBindings.delete(integerArrayLoop.localId);
                 break;
             }
             case "forOf": {
@@ -4083,7 +4219,7 @@ export class LlEmitter {
             // to this expression's frame so they survive those reads and still
             // die on the path that created them, including inside lazy branches.
             this.scopes.push([]);
-            const result = emitOperatorExpr(this, e);
+            const result = emitBorrowedFieldSequence(this, e) ?? emitOperatorExpr(this, e);
             for (const local of this.scopes.pop()) {
                 this.currentFrame().push({ name: local.slot, type: local.type, slot: true, ...(local.boxed ? { boxed: true } : {}) });
             }
@@ -4170,6 +4306,8 @@ export class LlEmitter {
     emitReadReceiver(e) {
         if (!isRefCounted(e.type))
             return this.emitExpr(e);
+        if (e.kind === "strLit")
+            return { name: this.internLiteral(e.value), type: e.type };
         if (e.kind === "varRef") {
             const binding = this.binding(e.localId);
             // Capture boxes can carry TDZ and caught-value conversion semantics.
@@ -4192,8 +4330,43 @@ export class LlEmitter {
                 : this.classFieldPtr(receiver.name, e.className, e.field);
             return { name: this.loadField(ptr, type), type: e.type };
         }
+        if (e.kind === "ternary" && this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_)) {
+            // Checked projections lower to a ternary with an always-throwing
+            // arm. Keep that check at the use, but borrow the successful arm.
+            const B = this.B;
+            const cond = this.emitExpr(e.cond);
+            const slot = B.slot();
+            B.entryAllocas.push(`${slot} = alloca ptr`);
+            const yes = B.newLabel("read.then"), no = B.newLabel("read.else"), join = B.newLabel("read.join");
+            B.condBr(cond.name, yes, no);
+            for (const [label, value] of [[yes, e.then], [no, e.else_]]) {
+                B.startBlock(label);
+                this.frames.push([]);
+                const result = this.emitReadReceiver(value);
+                B.line(`store ptr ${result.name}, ptr ${slot}`);
+                this.releaseFrame(this.frames.pop());
+                B.br(join);
+            }
+            B.startBlock(join);
+            const value = B.tmp();
+            B.line(`${value} = load ptr, ptr ${slot}`);
+            return { name: value, type: e.type };
+        }
         return this.emitExpr(e);
     }
+    canBorrowReceiver(e) {
+        switch (e.kind) {
+            case "varRef": return this.binding(e.localId).kind !== "boxed";
+            case "unionNarrow": return this.canBorrowReceiver(e.value);
+            case "fieldGet":
+            case "recordGet": return this.canBorrowReceiver(e.obj);
+            case "ternary": return this.canBorrowReceiver(e.then) && this.canBorrowReceiver(e.else_);
+            // The runtime always sets a pending exception; its unreachable
+            // typed dummy is null and owns no receiver.
+            case "libCall": return e.fn === "error.nodeThrow";
+            default: return false;
+        }
+    }
     emitExpr(e) {
         return emitExpr(this, e);
     }