@scriptc/compiler 0.2.9 → 0.2.10

package/dist/backend/llvm/emitter.js

@@ -36,6 +36,7 @@ import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
 import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js";
 import { everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges, INT32_RANGE } from "../../ir/integer-ranges.js";
+import { unshareNodes } from "../../ir/unshare.js";
 import { analyzeInt32Slots } from "../../ir/int32-slots.js";
 import { analyzeFinalFields, constructorClass } from "../../ir/final-fields.js";
 import { foldConstantGlobals } from "../../ir/constant-globals.js";
@@ -56,10 +57,11 @@ import { CheckedNarrows, emitCheckedNarrowReceiver } from "./checked-narrows.js"
 import { emitDenseArrayGet, emitDenseArraySet } from "./dense-array-access.js";
 import { emitStackMapRead, findMapReadLifetimes, matchMapRead, } from "./map-read-lifetimes.js";
 import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
-import { emitBorrowedInput } from "./borrowed-inputs.js";
+import { borrowableInputs, emitBorrowedInput } from "./borrowed-inputs.js";
 import { analyzeWalks, findWalkBorrows } from "./walk-borrows.js";
 import { findReboundParameters } from "./rebound-parameters.js";
 import { ReferenceEffects } from "./reference-effects.js";
+import { ReferenceWrites } from "./reference-writes.js";
 import { LlvmDebugInfo } from "./debug-info.js";
 import { StackCallbacks } from "./stack-callbacks.js";
 import { findLoopArrayBorrows } from "./loop-array-borrows.js";
@@ -75,6 +77,7 @@ import { emitBorrowedResultCall, emitCallExpr } from "./expr-calls.js";
 import { emitDynamicExpr } from "./expr-dynamic.js";
 import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js";
 import { PublishWalkers } from "./publish.js";
+import { computeImmutableFields, stableGlobals } from "../immutability.js";
 import { computePublishedTypes } from "../publication.js";
 import { emitJsInteropExpr, emitExpr } from "./expr-dispatch.js";
 import { emitJsMarshal, emitJsOp, emitJsExit, islandAdapter, islandTypedAdapter, } from "./expr-island.js";
@@ -97,7 +100,7 @@ import { LlWalkers } from "./walkers.js";
 import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js";
 import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { literalCapWord, literalCapWord32 } from "./string-key-hash.js";
-import { NUMBER_MAP_ENTRY_DECL } from "./map-number-lookup.js";
+import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-lookup.js";
 import { STRING_READ_HELPERS } from "./string-reads.js";
 import { emitConcatInputs, emitMixedConcat, numberPart, stringParts, } from "./string-construction.js";
 import { arrNewCall, boxAccess, boxNewCall, boxReleaseSym, computeTraced, elemAccess, emitInlineRcHelpers, emitNullableRetainWrappers, FN_ATTRS, inlineRcDecls, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
@@ -127,14 +130,18 @@ function ffiCallbackDummyLl(callback) {
             return "i32 0";
     }
 }
-export function emitLlvmModule(mod, options = {}) {
+export function emitLlvmModule(input, options = {}) {
+    // Facts are keyed by node identity: emit the same module whether it was
+    // lowered in memory or read back from its serialized form.
+    const mod = unshareNodes(input);
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined
         ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
         : mod, options).emit();
 }
 /** Keep large translation units below the host's single-string limit. */
-export function emitLlvmModuleSource(mod, options = {}) {
+export function emitLlvmModuleSource(input, options = {}) {
+    const mod = unshareNodes(input);
     const parts = new LlEmitter(options.debugSources === undefined
         ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction))
         : mod, options).emitParts();
@@ -302,6 +309,12 @@ export class LlEmitter {
      * fiberless-async analysis scans it for suspension entry points. */
     fnDefText = new Map();
     referenceEffects;
+    /** Field-sensitive reference writes (null in debug builds). */
+    referenceWrites = null;
+    borrowedReturnKeyCache = new Map();
+    /** The statement list being emitted and the current index, for blocks
+     * whose bindings end with the list (emitBlock and function bodies). */
+    stmtCursor = null;
     optionalArrayReads;
     checkedNarrows;
     callArrayReads = new Map();
@@ -345,6 +358,9 @@ export class LlEmitter {
     ffiHasRetainedCallback;
     ffiHasForeignCallback;
     globalTypes = new Map();
+    /** Module constants that keep one value once initialized
+     * (immutability.ts stableGlobals). */
+    stableGlobals = new Set();
     tdzGlobals = new Map();
     constantNumericTables;
     /** May-throw analysis (computeMayThrow): pending
@@ -360,6 +376,13 @@ export class LlEmitter {
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     publishedTypes;
+    /** Construction-only class and record fields (immutability.ts); null
+     * where the facts are disabled. */
+    immutableFields;
+    /** Constructor function names: their bodies may still write their own
+     * `this`'s construction-only fields. */
+    constructorFunctions;
+    inConstructor = false;
     /** Method names with at least one may-throw implementation — the
      * virtualCall pending check's key. */
     mayThrowMethods = new Set();
@@ -436,6 +459,12 @@ export class LlEmitter {
     initializerBindings;
     /** Whole-program int32 storage and parameter/result facts. */
     int32Slots;
+    /** Immutable module constants (contract types) whose graphs become
+     * immortal once initialized: their reads need no reference counting. */
+    immortalGlobals;
+    /** ProgramLifetime hierarchy roots (contract types): their instances are
+     * immortal from construction (classes.ts programLifetimeClass). */
+    programLifetime;
     numericLocals = new Map();
     captureIds = new Set();
     /** Active induction bindings retain their width independently of size_t. */
@@ -495,6 +524,8 @@ export class LlEmitter {
         this.constantNumericTables = findConstantNumericTables(mod);
         this.initializerBindings = findInitializerBindings(mod);
         this.int32Slots = analyzeInt32Slots(mod);
+        this.immortalGlobals = new Set(mod.contracts?.immortalGlobals ?? []);
+        this.programLifetime = new Set(mod.contracts?.programLifetime ?? []);
         this.finalFields = analyzeFinalFields(mod);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.ffiExtendNarrowIntegers =
@@ -549,6 +580,8 @@ export class LlEmitter {
         this.workerEntryPolls = mt.workerEntryPolls ?? null;
         this.stackChecks = mt.stackChecks ?? null;
         this.publishedTypes = computePublishedTypes(mod);
+        this.immutableFields = computeImmutableFields(mod);
+        this.constructorFunctions = new Set((mod.classes ?? []).map((c) => `%${c.name}.constructor`));
         this.indirectMayThrow = mt.indirect || mod.workers === true;
         for (const cls of mod.classes ?? []) {
             for (const m of cls.methods ?? []) {
@@ -568,6 +601,8 @@ export class LlEmitter {
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById, (id) => this.nullableUnions.has(id));
         this.checkedNarrows = new CheckedNarrows(this.fnByName);
         this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null, mod.classes ?? []);
+        if (this.debug === null)
+            this.referenceWrites = new ReferenceWrites(this.fnByName, mod.classes ?? [], (call) => this.optionalArrayReads.get(call) !== null, new Set((mod.globals ?? []).map((g) => g.id)), { unions: mod.unions, records: mod.records }, this.immutableFields);
         const walkParameters = new Map();
         if (this.debug === null) {
             const host = {
@@ -575,9 +610,10 @@ export class LlEmitter {
                 borrowsWithoutOwning: (e) => this.borrowsWithoutOwning(e),
             };
             for (const fn of this.fnByName.values()) {
-                if (!this.referenceEffects.functions.has(fn.name))
+                const preserving = this.referenceEffects.functions.has(fn.name);
+                if (!preserving && this.referenceWrites === null)
                     continue;
-                const walks = findWalkBorrows(fn, host);
+                const walks = findWalkBorrows(fn, preserving ? host : this.unwrittenWalkHost(fn, host));
                 if (walks.size === 0)
                     continue;
                 this.walkBorrowsByFunction.set(fn.name, walks);
@@ -661,6 +697,7 @@ export class LlEmitter {
             },
             pendingTestLines: (dest) => this.pendingTestLines(dest),
             virtualEntry: (implFn) => this.virtualEntry(implFn),
+            programLifetime: this.programLifetime,
         };
         this.walkers = new LlWalkers(this.shapeHost);
         this.dyn = new LlDyn(this.shapeHost);
@@ -682,6 +719,7 @@ export class LlEmitter {
             if (g.tdz)
                 this.tdzGlobals.set(g.id, g.name);
         }
+        this.stableGlobals = stableGlobals(mod);
         // Runtime error, EventEmitter, and stream classes have known layouts.
         // Subclasses embed the ScrEmitter/ScrStream prefixes from classes.ts.
         const classes = mod.classes ?? [];
@@ -1403,12 +1441,14 @@ export class LlEmitter {
             `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
             `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr, ptr }`,
             // ScrArr mirrors scr_runtime.h field-for-field: { rc, len, cap, elem,
-            // elem_retain, elem_release, elem_trace, data, present, ext }, where
-            // ext points at the out-of-line sparse, property and metadata storage
-            // (NULL until first used). Live dynamic stream commits swap its dense,
-            // presence and out-of-line storage while preserving the target
-            // object's identity.
-            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr }`,
+            // cyc, ops, data, present, ext } (field numbers in SCR_ARR_FIELD),
+            // where ops points at the element type's constant RC descriptor
+            // (%ScrArrOps, SCR_ELEM_REF only) and ext at the out-of-line sparse,
+            // property and metadata storage (NULL until first used). Live dynamic
+            // stream commits swap its dense, presence and out-of-line storage while
+            // preserving the target object's identity.
+            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr }`,
+            `%ScrArrOps = type { ptr, ptr, ptr }`,
             // The ScrMap prefix { rc, key_kind, val_kind, val_retain, val_release,
             // val_trace, key_retain, key_release, key_trace } — the inline RC
             // fast paths test the two trace slots (shapes.ts).
@@ -1421,9 +1461,13 @@ export class LlEmitter {
             ...(this.decls.has(NUMBER_MAP_ENTRY_DECL)
                 ? [
                     `%ScrMapIx = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ptr, ptr, ${this.sizeType} }`,
-                    `%ScrMapEntry = type { i64, i64, i64 }`,
                 ]
                 : []),
+            // String-keyed reference reads load the value slot of the entry
+            // scr_map_entry_str returns (map-number-lookup.ts).
+            ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL)
+                ? [`%ScrMapEntry = type { i64, i64, i64 }`]
+                : []),
             // The runtime error prefix { rc, vt, name, message, code, cause } and the
             // class-object shape { rc, pre, post, ctor, name } — field reads on
             // builtin errors and classval loads GEP through these.
@@ -1551,7 +1595,7 @@ export class LlEmitter {
             // strings — a no-op.
             const n = inst.slots.length;
             const present = n === 0 ? "zeroinitializer" : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
-            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`);
+            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, i32 0, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`);
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
@@ -4086,6 +4130,7 @@ export class LlEmitter {
         const numericFn = withInitializerBindings(fn, initializerBindings);
         this.numericLocals = new Map(numericFn.locals.map((l) => [l.id, l]));
         this.borrowedParameters.clear();
+        this.referenceWrites?.enter(fn);
         this.reboundOwnerSlots.clear();
         this.projectedParameters.clear();
         const projectedParameterIndexes = this.callLifetimes.parameters.get(fn.name);
@@ -4117,7 +4162,7 @@ export class LlEmitter {
         this.integerArrayBindings.clear();
         this.loopArrayBorrows =
             this.debug === null
-                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads)
+                ? findLoopArrayBorrows(fn, this.callLifetimes, this.referenceEffects, this.optionalArrayReads, this.referenceWrites)
                 : new Set();
         this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.referenceEffects.functions, this.callLifetimes, this.optionalArrayReads, this.loopArrayBorrows, this.debug === null ? this.referenceEffects : undefined);
         this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.referenceEffects.functions, this.callLifetimes, this.debug === null ? this.referenceEffects : undefined);
@@ -4137,6 +4182,7 @@ export class LlEmitter {
         this.currentReturnType = fn.returnType;
         this.currentGenerator = fn.generator ?? null;
         this.currentBorrowedReturn = this.borrowedReturns.has(fn.name);
+        this.inConstructor = this.constructorFunctions.has(fn.name);
         this.currentWasiCoro = null;
         this.logArgSlots = 0;
         if (this.wasi && (fn.async === true || fn.generator !== undefined)) {
@@ -4297,7 +4343,7 @@ export class LlEmitter {
             this.emitStackCheck();
         if (this.workerEntryPolls?.has(fn.name))
             this.emitPendingCheck(undefined, true);
-        this.emitStmts(fn.body);
+        this.emitStmts(fn.body, true);
         // Implicit exit of a void function: release the function scope unless
         // the body already terminated its final block (return, or a throw
         // whose unwind released everything down to depth 0).
@@ -4363,7 +4409,14 @@ export class LlEmitter {
         if (fn.captures !== undefined)
             params.unshift("ptr %sc_env");
         const ret = this.llType(fn.returnType);
-        const attrs = coro !== null ? "#1" : FN_ATTRS;
+        let attrs = coro !== null ? "#1" : FN_ATTRS;
+        // The shared indexed-read helper (lowerSafeIndexRead) is a dense bounds
+        // test, a state test and a load behind cold runtime fallbacks, called
+        // from every `a[i]` of one element type. Without the hint LLVM keeps the
+        // hot instances out of line once they have many callers: every read pays
+        // a call, and an integer index converts to a double and back across it.
+        if (fn.name.startsWith("%arr.idxOr."))
+            attrs = `inlinehint ${attrs}`;
         const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`;
         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}`;
@@ -4460,6 +4513,10 @@ export class LlEmitter {
                 this.canBorrowReceiver(value.else_) &&
                 this.canBorrowCallArgument(value.then) &&
                 this.canBorrowCallArgument(value.else_));
+        // A construction-only field of a stable owner keeps its value until the
+        // owner dies: no later operand or callee can replace and release it.
+        if ((value.kind === "fieldGet" || value.kind === "recordGet") && this.immutableRead(value))
+            return this.canBorrowCallArgument(value.obj);
         // An optional chain's bound receiver stays unchanged until its body
         // finishes (see emitReadReceiver).
         if (value.kind === "chainRecv")
@@ -4467,6 +4524,9 @@ export class LlEmitter {
         if (value.kind !== "varRef")
             return false;
         const binding = this.binding(value.localId);
+        // A module constant owns its value for the rest of the program.
+        if (binding.kind === "global")
+            return this.stableGlobals.has(value.localId);
         return (binding.kind === "local" &&
             binding.local !== undefined &&
             (!binding.local.mutable ||
@@ -4476,15 +4536,212 @@ export class LlEmitter {
             !binding.local.boxed &&
             !binding.local.tdz);
     }
+    /** A plain-pointer read of a construction-only field outside any
+     * constructor (ImmutableFields). */
+    immutableRead(e) {
+        if (this.inConstructor || this.immutableFields === null)
+            return false;
+        const t = e.type.kind;
+        if (t !== "object" && t !== "record" && t !== "array" && t !== "string")
+            return false;
+        return e.kind === "fieldGet"
+            ? this.immutableFields.classField(e.className, e.field)
+            : this.immutableFields.recordField(e.shapeId, e.field);
+    }
+    /** A projection read whose locations nothing writes while a borrowed
+     * read of it is in use (ReferenceWrites), given the writes of that
+     * extent. The root binding itself must stay alive across it too, which
+     * its own location (`l:`, `g:`, `bx`) covers. */
+    unwrittenRead(e, writes) {
+        const rw = this.referenceWrites;
+        if (rw === null)
+            return false;
+        const keys = rw.readKeys(e, (call) => this.borrowedReturnKeys(call.callee));
+        return keys !== null && !rw.conflicts(keys, writes);
+    }
+    /** A stable binding initialized by a projection can borrow it when the
+     * rest of its block (its whole lifetime) writes none of the projection's
+     * locations: the source edge then keeps the value alive, and uses that
+     * escape still retain their own copies. */
+    unwrittenAlias(s) {
+        const cursor = this.stmtCursor;
+        const rw = this.referenceWrites;
+        if (rw === null || s.init === null || cursor === null || cursor.stmts[cursor.index] !== s)
+            return false;
+        if (!this.plainReference(s.init.type) ||
+            !this.canBorrowReceiver(s.init) ||
+            !this.unownedWalk(s.init))
+            return false;
+        const writes = rw.union([rw.expr(s.init), rw.stmts(cursor.stmts.slice(cursor.index + 1))]);
+        return this.unwrittenRead(s.init, writes);
+    }
+    /** An optional element read into a projection-only local can borrow the
+     * element when the rest of the block writes no array element and none of
+     * the locations keeping the array alive (which must itself be read
+     * without a frame owner). */
+    unwrittenLocalArrayRead(s, read) {
+        const cursor = this.stmtCursor;
+        const rw = this.referenceWrites;
+        if (rw === null || s.init === null || cursor === null || cursor.stmts[cursor.index] !== s)
+            return false;
+        if (!this.unownedWalk(read.array))
+            return false;
+        const keys = rw.readKeys(read.array);
+        if (keys === null || rw.expr(read.index) !== null)
+            return false;
+        const writes = rw.union([rw.expr(s.init), rw.stmts(cursor.stmts.slice(cursor.index + 1))]);
+        return !rw.conflicts(["a", ...keys], writes);
+    }
+    /** An optional element read passed to a projection-only parameter can
+     * borrow the element when the callee and later arguments (`writes`)
+     * write no array element and nothing keeping the array alive. */
+    unwrittenCallArrayRead(read, writes) {
+        const rw = this.referenceWrites;
+        if (rw === null)
+            return false;
+        const keys = rw.readKeys(read.array);
+        if (keys === null || rw.expr(read.index) !== null)
+            return false;
+        return !rw.conflicts(["a", ...keys], writes);
+    }
+    /** `return x` of a local whose slot is an owned scope entry of the same
+     * type: the return can take over the local's reference. */
+    movableReturn(value) {
+        if (value === null || value.kind !== "varRef" || !isRefCounted(value.type))
+            return null;
+        if (this.currentBorrowedReturn || this.currentWasiCoro !== null)
+            return null;
+        const binding = this.binding(value.localId);
+        if (binding.kind !== "local" || binding.local === undefined || binding.local.boxed)
+            return null;
+        if (!typeEquals(binding.type, value.type) || !typeEquals(this.currentReturnType, value.type))
+            return null;
+        for (const scope of this.scopes) {
+            const index = scope.findIndex((entry) => entry.slot === binding.slot);
+            if (index < 0)
+                continue;
+            const entry = scope[index];
+            if (entry.boxed || entry.lazy || !typeEquals(entry.type, value.type))
+                return null;
+            return { scope, entry, index };
+        }
+        return null;
+    }
+    /** A walk host for a body that may write the heap: each walk must read
+     * only locations the whole body (with its callees) never writes;
+     * rebinding the walk locals themselves releases nothing. */
+    unwrittenWalkHost(fn, host) {
+        return {
+            ...host,
+            unwritten: (value, candidates) => this.referenceWrites?.unwrittenWalk(fn, value, candidates, (call) => this.borrowedReturnKeys(call.callee)) ?? false,
+        };
+    }
+    /** emitReadReceiver yields a plain pointer for `e` that no statement
+     * frame owns, so it can outlive the statement (walk-borrows' walks, from
+     * any unboxed plain-pointer binding, plus element reads). */
+    unownedWalk(e) {
+        switch (e.kind) {
+            case "varRef": {
+                const binding = this.binding(e.localId);
+                if (binding.kind === "global")
+                    return this.plainReference(binding.type);
+                return (binding.kind === "local" &&
+                    binding.local !== undefined &&
+                    !binding.local.boxed &&
+                    !binding.local.tdz &&
+                    this.plainReference(binding.local.type) &&
+                    !this.stringSlices.has(e.localId) &&
+                    !this.storedSplits.has(e.localId) &&
+                    !this.localUnionStorage.has(e.localId));
+            }
+            case "fieldGet":
+            case "recordGet":
+                return this.borrowsWithoutOwning(e) && this.unownedWalk(e.obj);
+            case "unionNarrow":
+            case "downcast":
+            case "upcast":
+                return this.borrowsWithoutOwning(e) && this.unownedWalk(e.value);
+            case "unionWrap":
+                if (!this.borrowsWithoutOwning(e))
+                    return false;
+                return e.value.kind === "unitLit" || this.unownedWalk(e.value);
+            case "ternary": {
+                const arm = (v) => (v.kind === "libCall" && v.fn === "error.nodeThrow") || this.unownedWalk(v);
+                return this.borrowsWithoutOwning(e) && arm(e.then) && arm(e.else_);
+            }
+            case "call":
+                return (this.borrowsWithoutOwning(e) &&
+                    e.args.every((arg) => !isRefCounted(arg.type) || this.unownedWalk(arg)));
+            case "arrayGet":
+                return (!this.isStackUnionSource(e) &&
+                    this.optionalArrayReads.get(e) === null &&
+                    this.unownedWalk(e.arr));
+            case "seqExpr": {
+                const guarded = guardedValue(e);
+                return guarded !== null && this.unownedWalk(guarded);
+            }
+            default:
+                return false;
+        }
+    }
+    /** Every location a borrowed-return callee's walks can read (its body's
+     * field, record and element reads, through nested borrowed returns). */
+    borrowedReturnKeys(callee) {
+        if (!this.borrowedReturns.has(callee))
+            return null;
+        const known = this.borrowedReturnKeyCache.get(callee);
+        if (known)
+            return known;
+        const rw = this.referenceWrites;
+        const keys = new Set();
+        const seen = new Set([callee]);
+        const pending = [callee];
+        while (pending.length > 0) {
+            const fn = this.fnByName.get(pending.pop());
+            if (!fn)
+                continue;
+            everyStmtList(fn.body, {
+                stmt: () => true,
+                expr: (e) => {
+                    if (e.kind === "fieldGet")
+                        keys.add(rw.fieldKey(e.className, e.field));
+                    else if (e.kind === "recordGet") {
+                        keys.add(`r:${e.field}`);
+                        keys.add("r:*");
+                    }
+                    else if (e.kind === "arrayGet")
+                        keys.add("a");
+                    else if (e.kind === "call" && this.borrowedReturns.has(e.callee) && !seen.has(e.callee)) {
+                        seen.add(e.callee);
+                        pending.push(e.callee);
+                    }
+                    return true;
+                },
+            });
+        }
+        const result = [...keys];
+        this.borrowedReturnKeyCache.set(callee, result);
+        return result;
+    }
     // ── statements ──────────────────────────────────────────────────────────
-    emitStmts(stmts) {
-        for (const s of stmts) {
-            // Statements after a terminator are unreachable (dead code after
-            // return/break/continue). Skip them so no dropped SSA definition
-            // can leak forward.
-            if (this.B.isTerminated())
-                return;
-            this.emitStmt(s);
+    emitStmts(stmts, scoped = false) {
+        const saved = this.stmtCursor;
+        const cursor = scoped ? { stmts, index: 0 } : null;
+        try {
+            for (let i = 0; i < stmts.length; i++) {
+                // Statements after a terminator are unreachable (dead code after
+                // return/break/continue). Skip them so no dropped SSA definition
+                // can leak forward.
+                if (this.B.isTerminated())
+                    return;
+                if (cursor)
+                    cursor.index = i;
+                this.stmtCursor = cursor;
+                this.emitStmt(stmts[i]);
+            }
+        }
+        finally {
+            this.stmtCursor = saved;
         }
     }
     /** Emits a block in its own lexical scope (refcounted locals released at
@@ -4496,7 +4753,7 @@ export class LlEmitter {
         const scope = [];
         this.scopes.push(scope);
         setup?.(scope);
-        this.emitStmts(stmts);
+        this.emitStmts(stmts, true);
         const ended = endsWithJump(stmts);
         this.scopes.pop();
         if (!ended)
@@ -4558,7 +4815,9 @@ export class LlEmitter {
                 }
                 const localRead = this.localArrayReads.get(s.localId);
                 if (localRead) {
-                    const owner = emitLocalArrayRead(this, localRead, b.slot);
+                    const owner = emitLocalArrayRead(this, !localRead.borrow && this.unwrittenLocalArrayRead(s, localRead)
+                        ? { ...localRead, borrow: true }
+                        : localRead, b.slot);
                     if (owner)
                         this.scopes[this.scopes.length - 1].push(owner);
                     break;
@@ -4652,7 +4911,7 @@ export class LlEmitter {
                     b.local &&
                     isRefCounted(b.type) &&
                     this.stableCallBindings.has(s.localId) &&
-                    this.canBorrowCallArgument(s.init)) {
+                    (this.canBorrowCallArgument(s.init) || this.unwrittenAlias(s))) {
                     const v = this.emitReadReceiver(s.init);
                     B.line(`store ptr ${v.name}, ptr ${b.slot}`);
                     break;
@@ -4719,6 +4978,32 @@ export class LlEmitter {
                 }
                 B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`);
                 this.storeIntegerView(s.localId, v, s.value);
+                if (b.kind === "global" && this.immortalGlobals.has(s.localId)) {
+                    // An Immutable module constant (contracts/check.ts proved it is
+                    // fresh, publishable and never written): its graph becomes
+                    // immortal, so reads skip reference counting and the collector
+                    // never visits it.
+                    const lines = this.publishWalkers.emitPublish(v.name, v.type, s.loc);
+                    for (const line of lines)
+                        B.line(line.trimStart());
+                    // Reads of this global skip retains from here on, which is only
+                    // sound once the graph really is immortal. Node.js never fails
+                    // here, so a refusal means the contract proof was wrong: stop
+                    // rather than keep running with a mortal graph read as immortal.
+                    if (lines.length > 0) {
+                        this.declare(`declare zeroext i1 @scr_exc_pending()`);
+                        this.declare(`declare void @scr_trap(ptr)`);
+                        const refused = B.tmp();
+                        B.line(`${refused} = call zeroext i1 @scr_exc_pending()`);
+                        const stop = B.newLabel("immutable.refused");
+                        const done = B.newLabel("immutable.published");
+                        B.condBr(refused, stop, done);
+                        B.startBlock(stop);
+                        B.line(`call void @scr_trap(ptr ${this.cstr("scriptc: internal error: an Immutable value could not be published\n")})`);
+                        B.terminate("unreachable");
+                        B.startBlock(done);
+                    }
+                }
                 break;
             }
             case "exprStmt":
@@ -4816,14 +5101,14 @@ export class LlEmitter {
                     const obj = this.emitStableReceiver(s.obj, [s.value]);
                     // (The guard precedes the value here: the nullable store
                     // evaluates it itself.)
-                    this.emitPublishedFieldGuard(obj.name, s.className, s.field);
+                    this.emitStoreGuard(obj.name, s);
                     this.emitNullableFieldStore(obj.name, s.className, s.field, nullable, s.value);
                     break;
                 }
                 if (s.kind === "fieldSet" && this.int32Slots.isField(s.className, s.field)) {
                     const obj = this.emitStableReceiver(s.obj, [s.value]);
                     const v = this.emitExpr(s.value);
-                    this.emitPublishedFieldGuard(obj.name, s.className, s.field);
+                    this.emitStoreGuard(obj.name, s);
                     const { ptr } = this.classFieldPtr(obj.name, s.className, s.field);
                     this.storeInt32Field(ptr, v, s.value);
                     break;
@@ -4831,7 +5116,7 @@ export class LlEmitter {
                 const obj = this.emitStableReceiver(s.obj, [s.value]);
                 const v = this.emitExpr(s.value);
                 if (s.kind === "fieldSet")
-                    this.emitPublishedFieldGuard(obj.name, s.className, s.field);
+                    this.emitStoreGuard(obj.name, s);
                 else if (this.publishedTypes?.recordGuarded(s.shapeId) === true)
                     this.emitPublishedFieldGuard(obj.name, null, s.field);
                 const { ptr, type } = s.kind === "fieldSet"
@@ -5194,7 +5479,11 @@ export class LlEmitter {
                     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}`);
+                        // The start is 0 or an enclosing array index plus one (at most
+                        // 2^32 - 1): on 64-bit targets the signed conversion is exact
+                        // and avoids x86-64's unsigned 64-bit conversion sequence.
+                        const conversion = this.sizeType === "i64" ? "fptosi" : "fptoui";
+                        B.line(`${start} = ${conversion} double ${value.name} to ${this.sizeType}`);
                         this.integerArrayBindings.add(integerLoop.localId);
                     }
                     B.line(`store ${this.sizeType} ${start}, ptr ${integerSlot}`);
@@ -5500,10 +5789,32 @@ export class LlEmitter {
                 // the actual ret. The parked value owns a synthetic slot-backed
                 // scope entry during each copy so a throwing finally releases it.
                 let v = null;
-                if (s.value !== null && this.currentBorrowedReturn) {
+                const moved = this.finallyStack.length === 0 ? this.movableReturn(s.value) : null;
+                if (moved !== null) {
+                    // Returning an owned local hands its reference to the caller: no
+                    // retain now and no release of the local below.
+                    const t = B.tmp();
+                    B.line(`${t} = load ptr, ptr ${moved.entry.slot}`);
+                    v = { name: t, type: s.value.type };
+                    moved.scope.splice(moved.scope.indexOf(moved.entry), 1);
+                    this.releaseForJump(0, 0);
+                    moved.scope.splice(moved.index, 0, moved.entry);
+                }
+                else if (s.value !== null && this.currentBorrowedReturn) {
                     // A borrowed-return body hands back its walk without a reference
-                    // (it has no try statements, so no finally can intervene).
-                    v = this.emitReadReceiver(s.value);
+                    // (it has no try statements, so no finally can intervene). An
+                    // optional element read lends the element its array keeps alive.
+                    const read = this.optionalArrayReads.get(s.value);
+                    if (read) {
+                        const slot = B.slot();
+                        B.entryAllocas.push(`${slot} = alloca ptr`);
+                        emitLocalArrayRead(this, { ...read, borrow: true }, slot);
+                        const t = B.tmp();
+                        B.line(`${t} = load ptr, ptr ${slot}`);
+                        v = { name: t, type: s.value.type };
+                    }
+                    else
+                        v = this.emitReadReceiver(s.value);
                 }
                 else if (s.value !== null) {
                     v = this.emitExpr(s.value);
@@ -5540,7 +5851,7 @@ export class LlEmitter {
                     this.finallyStack = savedFinally;
                     this.tryStack = savedTry;
                 }
-                else {
+                else if (moved === null) {
                     this.releaseForJump(0, 0);
                 }
                 if (!B.isTerminated()) {
@@ -5798,7 +6109,7 @@ export class LlEmitter {
         const caseLabels = s.cases.map(() => B.newLabel("sw.c"));
         const defaultIdx = s.cases.findIndex((c) => c.test === null);
         const fallback = defaultIdx >= 0 ? caseLabels[defaultIdx] : end;
-        if (!emitLiteralSwitch(this, disc, s.cases, caseLabels, fallback)) {
+        if (!emitLiteralSwitch(this, disc, s.disc, s.cases, caseLabels, fallback)) {
             s.cases.forEach((c, i) => {
                 if (c.test === null)
                     return;
@@ -6134,6 +6445,13 @@ export class LlEmitter {
             ``,
         ];
     }
+    /** The frozen-object guard of a class field store, unless the store
+     * provably targets a still-private `this` (PublishedTypes.privateStores). */
+    emitStoreGuard(obj, s) {
+        if (this.publishedTypes?.privateStores.has(s) === true)
+            return;
+        this.emitPublishedFieldGuard(obj, s.className, s.field);
+    }
     /** The frozen-object guard of a class field or record field store:
      * Node's "Cannot assign to read only property" TypeError when the target
      * is published. `className` null means a record (`#<Object>`). */
@@ -6273,6 +6591,10 @@ export class LlEmitter {
                 this.ownSlot(result.owner.slot, result.owner.type);
             return result.value;
         }
+        // A borrowed-return helper (such as an optional element read) lends its
+        // result like any borrowed-return call.
+        if (e.kind === "call" && this.borrowedReturns.has(e.callee) && this.canBorrowReceiver(e))
+            return emitBorrowedResultCall(this, e);
         const arrayRead = this.optionalArrayReads.get(e);
         if (arrayRead)
             return emitProjectedArrayRead(this, arrayRead);
@@ -6518,12 +6840,24 @@ export class LlEmitter {
                 const wrap = this.borrowableNullableWrap(e);
                 return wrap === "unit" || (wrap === "ref" && this.canBorrowReceiver(e.value));
             }
-            // A borrowed-return callee preserves edges, so its result stays
-            // reachable from borrowable arguments until the consumer runs.
-            case "call":
-                return (this.borrowedReturns.has(e.callee) &&
-                    e.args.every((arg) => (!isRefCounted(arg.type) || this.canBorrowReceiver(arg)) &&
-                        this.referenceEffects.preserves(arg)));
+            // A borrowed-return result stays reachable from its borrowed
+            // arguments until the consumer runs. Each argument is lent without a
+            // snapshot, so neither the callee nor a later argument may replace
+            // what it was read from: a callee that preserves every edge cannot,
+            // and any other one must leave the argument's locations unwritten.
+            case "call": {
+                if (!this.borrowedReturns.has(e.callee))
+                    return false;
+                if (!e.args.every((arg) => this.referenceEffects.preserves(arg)))
+                    return false;
+                const preserving = this.referenceEffects.functions.has(e.callee);
+                if (preserving)
+                    return e.args.every((arg) => !isRefCounted(arg.type) || this.canBorrowReceiver(arg));
+                if (this.referenceWrites === null)
+                    return false;
+                const lent = borrowableInputs(this, e.args, false, this.referenceWrites.summary(e.callee));
+                return e.args.every((arg, i) => !isRefCounted(arg.type) || lent[i] === true);
+            }
             // A required element read: the (borrowed) array owns the element
             // while an edge-preserving index computes.
             case "arrayGet":
@@ -6569,14 +6903,17 @@ export class LlEmitter {
         };
         const hostFor = (fn) => {
             const allowed = borrowedIds(fn);
-            return {
+            const host = {
                 pointerLocal: (local) => pointer(local.type),
                 borrowsWithoutOwning: (e) => this.borrowsWithoutOwning(e),
                 borrowedReturn: (callee) => this.borrowedReturns.has(callee),
                 parameterAllowed: (id) => allowed.has(id),
             };
+            return this.referenceEffects.functions.has(fn.name) ? host : this.unwrittenWalkHost(fn, host);
         };
-        const preserving = [...this.fnByName.values()].filter((fn) => this.referenceEffects.functions.has(fn.name));
+        // With ReferenceWrites, a body that writes none of its walks' locations
+        // qualifies like one that preserves every edge.
+        const preserving = [...this.fnByName.values()].filter((fn) => this.referenceEffects.functions.has(fn.name) || this.referenceWrites !== null);
         const candidates = preserving.filter((fn) => {
             if (!pointer(fn.returnType) || fn.async || fn.generator || fn.captures)
                 return false;
@@ -6597,6 +6934,8 @@ export class LlEmitter {
                 if (!analyzeWalks(fn, hostFor(fn)).returnsWalk)
                     continue;
                 this.borrowedReturns.add(fn.name);
+                // Nested borrowed returns extend the locations a caller depends on.
+                this.borrowedReturnKeyCache.clear();
                 changed = true;
             }
         }
@@ -6624,6 +6963,12 @@ export class LlEmitter {
                 return this.nullableFieldGet(e) === null;
             case "recordGet":
                 return true;
+            // emitReadReceiver lends a required element of a borrowed array when
+            // computing the index removes no edge.
+            case "arrayGet":
+                return (e.arr.type.kind === "array" &&
+                    this.optionalArrayReads.get(e) === null &&
+                    this.referenceEffects.preserves(e.index));
             case "unionNarrow":
                 return this.nullableUnions.has(e.unionId);
             case "downcast":