@scriptc/compiler 0.2.5 → 0.2.7

package/dist/backend/llvm/constant-callbacks.test.js

@@ -0,0 +1,261 @@
+import { expect, test } from "vitest";
+import { BOOL, F64, VOID, funcOf, } from "../../ir/ir.js";
+import { analyzeCallLifetimes } from "./call-lifetimes.js";
+import { AmbientReceiverReaders, callbackIgnoresReceiver, findConstantCallbacks, } from "./constant-callbacks.js";
+const loc = { file: "callbacks.ts", start: 0, end: 0 };
+const callback = funcOf([F64], BOOL);
+const ref = (localId, type = callback) => ({ kind: "varRef", localId, type, loc });
+const closure = (fnName) => ({
+    kind: "closure",
+    fnName,
+    captures: [],
+    type: callback,
+    loc,
+});
+function fixture() {
+    const predicate = {
+        name: "predicate",
+        params: [{ localId: "n", name: "n", type: F64 }],
+        locals: [{ id: "n", name: "n", type: F64, mutable: true }],
+        returnType: BOOL,
+        body: [{ kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc }],
+        loc,
+    };
+    const consumer = {
+        name: "consume",
+        ownsPrototype: true,
+        params: [{ localId: "test", name: "test", type: callback }],
+        locals: [{ id: "test", name: "test", type: callback, mutable: true }],
+        returnType: BOOL,
+        body: [
+            {
+                kind: "return",
+                value: {
+                    kind: "callValue",
+                    callee: ref("test"),
+                    args: [{ kind: "numLit", value: 1, type: F64, loc }],
+                    type: BOOL,
+                    loc,
+                },
+                loc,
+            },
+        ],
+        loc,
+    };
+    const entry = {
+        name: "main",
+        params: [],
+        locals: [],
+        returnType: VOID,
+        body: [
+            {
+                kind: "exprStmt",
+                expr: { kind: "call", callee: "consume", args: [closure("predicate")], type: BOOL, loc },
+                loc,
+            },
+        ],
+        loc,
+    };
+    return {
+        irVersion: 15,
+        sourceFile: loc.file,
+        entry: "main",
+        functions: [predicate, consumer, entry],
+    };
+}
+function facts(mod) {
+    return findConstantCallbacks(mod, analyzeCallLifetimes(new Map(mod.functions.map((fn) => [fn.name, fn]))));
+}
+test("a closed consumer with one target specializes its callback parameter", () => {
+    expect(facts(fixture()).get("consume")?.get("test")).toBe("predicate");
+});
+test.each(["multiple", "escape", "write", "metadata", "suspend", "synthetic"])("%s prevents incoming-call specialization", (reason) => {
+    const mod = fixture();
+    const consumer = mod.functions[1];
+    const entry = mod.functions[2];
+    if (reason === "multiple") {
+        mod.functions.push({ ...mod.functions[0], name: "other" });
+        entry.body.push({
+            kind: "exprStmt",
+            expr: { kind: "call", callee: "consume", args: [closure("other")], type: BOOL, loc },
+            loc,
+        });
+    }
+    if (reason === "escape")
+        entry.body.push({
+            kind: "exprStmt",
+            expr: { ...closure("consume"), type: funcOf([callback], BOOL) },
+            loc,
+        });
+    if (reason === "write")
+        consumer.body.unshift({ kind: "assign", localId: "test", value: closure("predicate"), loc });
+    if (reason === "metadata")
+        mod.classes = [{ name: "Cell", fields: [], prototypeDataHelper: "consume", loc }];
+    if (reason === "suspend")
+        consumer.async = true;
+    if (reason === "synthetic")
+        delete consumer.ownsPrototype;
+    expect(facts(mod).get("consume")?.has("test")).not.toBe(true);
+});
+test("global closure aliases resolve without borrowing the caller's local namespace", () => {
+    const mod = fixture();
+    const entry = mod.functions[2];
+    mod.globals = [{ id: "%g.callback", name: "callback", type: callback, mutable: false }];
+    entry.locals = [{ id: "local", name: "local", type: callback, mutable: false }];
+    entry.body.unshift({ kind: "varDecl", localId: "local", init: closure("predicate"), loc }, { kind: "assign", localId: "%g.callback", value: ref("local"), loc });
+    const call = entry.body[2];
+    if (call.kind === "exprStmt" && call.expr.kind === "call")
+        call.expr.args = [ref("%g.callback")];
+    expect(facts(mod).get("consume")?.has("test")).not.toBe(true);
+    entry.body[1] = { kind: "assign", localId: "%g.callback", value: closure("predicate"), loc };
+    expect(facts(mod).get("consume")?.get("test")).toBe("predicate");
+    entry.body.push({ kind: "assign", localId: "%g.callback", value: closure("predicate"), loc });
+    expect(facts(mod).get("consume")?.has("test")).not.toBe(true);
+});
+test("receiver elision admits only synchronous receiver-free work", () => {
+    const fn = fixture().functions[0];
+    expect(callbackIgnoresReceiver(fn)).toBe(true);
+    // A fixed compile-fence throw cannot observe the receiver.
+    fn.body.unshift({ kind: "runtimeFence", code: "SC2020", message: "refused", loc });
+    expect(callbackIgnoresReceiver(fn)).toBe(true);
+    fn.body[0] = {
+        kind: "exprStmt",
+        expr: { kind: "libCall", fn: "dyn.this", args: [], type: { kind: "dyn" }, loc },
+        loc,
+    };
+    expect(callbackIgnoresReceiver(fn)).toBe(false);
+    fn.body.shift();
+    fn.async = true;
+    expect(callbackIgnoresReceiver(fn)).toBe(false);
+});
+function callsOf(name, callee, extra = []) {
+    return {
+        name,
+        params: [],
+        locals: [],
+        returnType: VOID,
+        body: [
+            ...extra,
+            { kind: "exprStmt", expr: { kind: "call", callee, args: [], type: VOID, loc }, loc },
+        ],
+        loc,
+    };
+}
+const thisRead = {
+    kind: "exprStmt",
+    expr: { kind: "libCall", fn: "dyn.this", args: [], type: { kind: "dyn" }, loc },
+    loc,
+};
+test("receiver readers propagate backwards through direct calls and recursion", () => {
+    const leaf = callsOf("leaf", "middle");
+    const middle = callsOf("middle", "leaf");
+    const functions = new Map([leaf, middle].map((fn) => [fn.name, fn]));
+    // A cycle with no reader is receiver-free.
+    expect(new AmbientReceiverReaders(functions).ignores(leaf)).toBe(true);
+    middle.body.unshift(thisRead);
+    const readers = new AmbientReceiverReaders(functions);
+    expect(readers.ignores(leaf)).toBe(false);
+    expect(readers.ignores(middle)).toBe(false);
+    // Unknown callees and async callees count as readers.
+    const unknown = callsOf("unknown", "missing");
+    expect(callbackIgnoresReceiver(unknown)).toBe(false);
+    const spawn = callsOf("spawn", "task");
+    const task = { ...callsOf("task", "spawn"), body: [], async: true };
+    expect(new AmbientReceiverReaders(new Map([spawn, task].map((fn) => [fn.name, fn]))).ignores(spawn)).toBe(false);
+});
+test("virtual calls admit every same-named method", () => {
+    const call = {
+        kind: "exprStmt",
+        expr: { kind: "virtualCall", className: "%A", method: "run", args: [], type: VOID, loc },
+        loc,
+    };
+    const caller = { ...callsOf("caller", "x"), body: [call] };
+    const a = { ...callsOf("%A.run", "x"), body: [] };
+    const b = { ...callsOf("%B.run", "x"), body: [] };
+    const functions = new Map([caller, a, b].map((fn) => [fn.name, fn]));
+    expect(new AmbientReceiverReaders(functions).ignores(caller)).toBe(true);
+    b.body = [thisRead];
+    expect(new AmbientReceiverReaders(functions).ignores(caller)).toBe(false);
+});
+test("synthetic array HOF helpers are constant-callback consumers", () => {
+    const mod = fixture();
+    const consumer = mod.functions[1];
+    const entry = mod.functions[2];
+    delete consumer.ownsPrototype;
+    consumer.name = "%arr.some.0";
+    const call = entry.body[0];
+    if (call.kind === "exprStmt" && call.expr.kind === "call")
+        call.expr.callee = "%arr.some.0";
+    expect(facts(mod).get("%arr.some.0")?.get("test")).toBe("predicate");
+});
+function factory(name, returns) {
+    return {
+        name,
+        params: [],
+        locals: [],
+        returnType: callback,
+        body: returns.map((value) => ({
+            kind: "if",
+            cond: { kind: "boolLit", value: true, type: BOOL, loc },
+            then: [{ kind: "return", value, loc }],
+            else_: null,
+            loc,
+        })),
+        loc,
+    };
+}
+test("a factory returning one function resolves through its call", () => {
+    const mod = fixture();
+    const entry = mod.functions[2];
+    mod.functions.push(factory("make", [closure("predicate")]));
+    const call = entry.body[0];
+    if (call.kind === "exprStmt" && call.expr.kind === "call")
+        call.expr.args = [{ kind: "call", callee: "make", args: [], type: callback, loc }];
+    expect(facts(mod).get("consume")?.get("test")).toBe("predicate");
+    mod.functions.push({ ...mod.functions[0], name: "other" });
+    mod.functions[3] = factory("make", [closure("predicate"), closure("other")]);
+    expect(facts(mod).get("consume")?.has("test")).not.toBe(true);
+});
+test("an immutable capture resolves at its closure creation site", () => {
+    const mod = fixture();
+    const entry = mod.functions[2];
+    const lambda = {
+        name: "%lambda",
+        params: [],
+        captures: [{ localId: "cb", name: "cb", type: callback }],
+        locals: [{ id: "cb", name: "cb", type: callback, mutable: false, boxed: true }],
+        returnType: BOOL,
+        body: [
+            {
+                kind: "return",
+                value: {
+                    kind: "callValue",
+                    callee: ref("cb"),
+                    args: [{ kind: "numLit", value: 1, type: F64, loc }],
+                    type: BOOL,
+                    loc,
+                },
+                loc,
+            },
+        ],
+        loc,
+    };
+    mod.functions.push(lambda);
+    entry.locals = [{ id: "cb", name: "cb", type: callback, mutable: false, boxed: true }];
+    entry.body.push({ kind: "varDecl", localId: "cb", init: closure("predicate"), loc }, {
+        kind: "exprStmt",
+        expr: {
+            kind: "closure",
+            fnName: "%lambda",
+            captures: ["cb"],
+            type: funcOf([], BOOL),
+            loc,
+        },
+        loc,
+    });
+    expect(facts(mod).get("%lambda")?.get("cb")).toBe("predicate");
+    entry.locals[0].mutable = true;
+    lambda.locals[0].mutable = true;
+    expect(facts(mod).get("%lambda")?.has("cb")).not.toBe(true);
+});
+//# sourceMappingURL=constant-callbacks.test.js.map

package/dist/backend/llvm/constant-callbacks.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-callbacks.test.js","sourceRoot":"","sources":["../../../src/backend/llvm/constant-callbacks.test.ts"],"names":[],"mappings":"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"}

package/dist/backend/llvm/dense-array-access.d.ts

@@ -0,0 +1,29 @@
+import { type IrExpr, type IrType } from "../../ir/ir.js";
+import type { LlValue, LlvmEmitterContext } from "./expr-context.js";
+export type ArrayAccess = "f64" | "bool" | "ref";
+/** Strict element read with the runtime getter's result contract: a
+ * double, an i1, or a pointer that is +1 (`retain`) or borrowed. The
+ * runtime getter keeps the trap for holes, present undefined, and missing
+ * properties; it also answers sparse indices. Null reference slots take
+ * the runtime path, which returns them without a retain. */
+export declare function emitDenseArrayGet(host: LlvmEmitterContext, array: string, index: LlValue, indexExpr: IrExpr | undefined, acc: ArrayAccess, element: IrType, getter: string, retain: boolean): string;
+/** `scr_arr_get_number`: a numeric element, or NaN for every missing,
+ * hole, or present-undefined slot (answered by the runtime). */
+export declare function emitDenseArrayNumber(host: LlvmEmitterContext, array: string, index: LlValue, indexExpr: IrExpr | undefined): string;
+/** `scr_arr_state` (as a double) or `scr_arr_has` (as an i1). Dense
+ * in-range indices answer from the state byte; everything else keeps the
+ * runtime query, including canonical indices at or past the length. */
+export declare function emitDenseArrayState(host: LlvmEmitterContext, array: string, index: LlValue, indexExpr: IrExpr | undefined, kind: "state" | "has"): string;
+/** Element write with `scr_arr_set_*` semantics: the array takes the
+ * value's reference. A dense index stores the slot, marks it present, and
+ * extends the length when it lands at or past it; a replaced present
+ * reference is released after the new edge is published (a release can
+ * collect cycles). Every other index takes the unchanged runtime call. */
+export declare function emitDenseArraySet(host: LlvmEmitterContext, array: string, index: LlValue, indexExpr: IrExpr | undefined, acc: ArrayAccess, element: IrType, value: string): void;
+/** `scr_arr_push_*` (the array takes the value's reference) returning the
+ * new length as a double. When `len < cap` the runtime's append is exactly
+ * a dense store at `len` plus `len + 1`: no sparse entry can exist past the
+ * length, nothing is released, and the dense capacity never exceeds the
+ * maximum index. A full array takes the unchanged (cold) runtime call,
+ * which grows storage. */
+export declare function emitDenseArrayPush(host: LlvmEmitterContext, array: string, acc: ArrayAccess, value: string): string;

package/dist/backend/llvm/dense-array-access.js

@@ -0,0 +1,335 @@
+/* Inline dense-storage fast paths for ordinary array element access.
+ *
+ * Every strict and optional element operation keeps its runtime entry as
+ * the authority: the inline path only answers the case the runtime itself
+ * answers from dense storage without side effects — a canonical integer
+ * index below both the array length and the dense capacity (and, for
+ * strict reads, a slot whose state is a present value). Holes, present
+ * `undefined`, sparse indices, noncanonical numeric properties (negative,
+ * fractional, NaN, infinite, 2^32-1), and out-of-range reads branch to the
+ * unchanged runtime call, which is marked cold. The ScrArr field indices
+ * match the C layout in scr_runtime.h: len 1, cap 2, data 7, present 8. */
+import { isRefCounted } from "../../ir/ir.js";
+import { exactInteger, widenInteger } from "./integer-values.js";
+const SCR_ARR_VALUE = 1;
+/** Call-site effects of the non-retaining read fallbacks: they only read
+ * module-visible memory, or trap without returning to the caller (the trap
+ * writes runtime-private stderr/TLS state). Declaring this lets LLVM keep
+ * array header loads out of loops whose only calls are these cold paths. */
+const READ_FALLBACK = " cold memory(read, inaccessiblemem: readwrite)";
+/** Branch to `slow` unless `index` names a canonical array index inside
+ * dense storage. Reads also require it below the length; writes may land
+ * at or past the length while still inside the dense capacity (the runtime
+ * then extends the length over hole states exactly the same way). */
+function emitDenseGuard(host, array, index, indexExpr, slow, requireBelowLen) {
+    const B = host.B;
+    const size = host.sizeType;
+    const integer = exactInteger(host, index, indexExpr);
+    let wide;
+    let integral = null;
+    if (integer) {
+        // A proven integer needs no double round-trip. Negative signed values
+        // compare above any length or capacity as unsigned 64-bit integers.
+        wide = widenInteger(host, integer);
+    }
+    else {
+        // freeze keeps NaN/out-of-range conversions from producing poison; the
+        // exact round-trip comparison then rejects every value that is not an
+        // integer, and -0 converts to index 0 exactly like the runtime's check.
+        // Any frozen value that passes the round-trip and the unsigned capacity
+        // comparison below is the exact index.
+        const raw = B.tmp(), back = B.tmp();
+        wide = B.tmp();
+        integral = B.tmp();
+        B.line(`${raw} = fptosi double ${index.name} to i64`);
+        B.line(`${wide} = freeze i64 ${raw}`);
+        B.line(`${back} = sitofp i64 ${wide} to double`);
+        B.line(`${integral} = fcmp oeq double ${back}, ${index.name}`);
+    }
+    const lenPtr = B.tmp(), len = B.tmp(), capPtr = B.tmp(), cap = B.tmp();
+    B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 1`);
+    host.markMemoryPointer(lenPtr, "array:header");
+    B.line(`${len} = load ${size}, ptr ${lenPtr}${host.fieldAliasAttachment(lenPtr)}`);
+    B.line(`${capPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 2`);
+    host.markMemoryPointer(capPtr, "array:header");
+    B.line(`${cap} = load ${size}, ptr ${capPtr}${host.fieldAliasAttachment(capPtr)}`);
+    // Load the storage bases before branching: the header of a live array is
+    // always readable, and unconditional loads let LLVM hoist them out of
+    // loops whose only calls are read-only fallbacks.
+    const dataPtr = B.tmp(), data = B.tmp(), statesPtr = B.tmp(), states = B.tmp();
+    B.line(`${dataPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 7`);
+    host.markMemoryPointer(dataPtr, "array:header");
+    B.line(`${data} = load ptr, ptr ${dataPtr}${host.fieldAliasAttachment(dataPtr)}`);
+    B.line(`${statesPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 8`);
+    host.markMemoryPointer(statesPtr, "array:header");
+    B.line(`${states} = load ptr, ptr ${statesPtr}${host.fieldAliasAttachment(statesPtr)}`);
+    const widen = (value) => {
+        if (size === "i64")
+            return value;
+        const t = B.tmp();
+        B.line(`${t} = zext i32 ${value} to i64`);
+        return t;
+    };
+    const conditions = [];
+    if (integral)
+        conditions.push(integral);
+    const belowCap = B.tmp();
+    B.line(`${belowCap} = icmp ult i64 ${wide}, ${widen(cap)}`);
+    conditions.push(belowCap);
+    if (requireBelowLen) {
+        const belowLen = B.tmp();
+        B.line(`${belowLen} = icmp ult i64 ${wide}, ${widen(len)}`);
+        conditions.push(belowLen);
+    }
+    let ok = conditions[0];
+    for (const c of conditions.slice(1)) {
+        const t = B.tmp();
+        B.line(`${t} = and i1 ${ok}, ${c}`);
+        ok = t;
+    }
+    const dense = B.newLabel("arr.dense");
+    B.condBr(ok, dense, slow);
+    B.startBlock(dense);
+    let offset = wide;
+    if (size !== "i64") {
+        offset = B.tmp();
+        B.line(`${offset} = trunc i64 ${wide} to i32`);
+    }
+    return { offset, len, data, states };
+}
+function statePointer(host, guard) {
+    const B = host.B;
+    const statePtr = B.tmp();
+    B.line(`${statePtr} = getelementptr inbounds i8, ptr ${guard.states}, ${host.sizeType} ${guard.offset}`);
+    host.markMemoryPointer(statePtr, "array:present");
+    return statePtr;
+}
+function valuePointer(host, guard) {
+    const B = host.B;
+    const valuePtr = B.tmp();
+    B.line(`${valuePtr} = getelementptr inbounds i64, ptr ${guard.data}, ${host.sizeType} ${guard.offset}`);
+    host.markMemoryPointer(valuePtr, "array:elements");
+    return valuePtr;
+}
+function loadState(host, guard) {
+    const ptr = statePointer(host, guard);
+    const state = host.B.tmp();
+    host.B.line(`${state} = load i8, ptr ${ptr}${host.fieldAliasAttachment(ptr)}`);
+    return state;
+}
+/** Strict element read with the runtime getter's result contract: a
+ * double, an i1, or a pointer that is +1 (`retain`) or borrowed. The
+ * runtime getter keeps the trap for holes, present undefined, and missing
+ * properties; it also answers sparse indices. Null reference slots take
+ * the runtime path, which returns them without a retain. */
+export function emitDenseArrayGet(host, array, index, indexExpr, acc, element, getter, retain) {
+    const B = host.B;
+    const ty = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
+    const ret = acc === "bool" ? "zeroext i1" : ty;
+    host.declare(`declare ${ret} @${getter}(ptr, double)`);
+    if (acc === "ref" && retain && !isRefCounted(element)) {
+        const t = B.tmp();
+        B.line(`${t} = call ${ty} @${getter}(ptr ${array}, double ${index.name})`);
+        return t;
+    }
+    const slow = B.newLabel("arr.get.slow"), join = B.newLabel("arr.get.join");
+    const guard = emitDenseGuard(host, array, index, indexExpr, slow, true);
+    const state = loadState(host, guard);
+    const present = B.tmp();
+    B.line(`${present} = icmp eq i8 ${state}, ${SCR_ARR_VALUE}`);
+    const valueLabel = B.newLabel("arr.get.value");
+    B.condBr(present, valueLabel, slow);
+    B.startBlock(valueLabel);
+    const ptr = valuePointer(host, guard);
+    let fast;
+    let fastLabel = valueLabel;
+    if (acc === "f64") {
+        fast = B.tmp();
+        B.line(`${fast} = load double, ptr ${ptr}${host.fieldAliasAttachment(ptr)}`);
+    }
+    else if (acc === "bool") {
+        const raw = B.tmp();
+        fast = B.tmp();
+        B.line(`${raw} = load i64, ptr ${ptr}${host.fieldAliasAttachment(ptr)}`);
+        B.line(`${fast} = icmp ne i64 ${raw}, 0`);
+    }
+    else {
+        const raw = B.tmp(), nonnull = B.tmp();
+        B.line(`${raw} = load ptr, ptr ${ptr}${host.fieldAliasAttachment(ptr)}`);
+        B.line(`${nonnull} = icmp ne ptr ${raw}, null`);
+        fastLabel = B.newLabel("arr.get.ref");
+        B.condBr(nonnull, fastLabel, slow);
+        B.startBlock(fastLabel);
+        fast = retain ? host.retainValue(raw, element) : raw;
+    }
+    B.br(join);
+    B.startBlock(slow);
+    const slowValue = B.tmp();
+    const attrs = acc === "ref" && retain ? " cold" : READ_FALLBACK;
+    B.line(`${slowValue} = call ${ty} @${getter}(ptr ${array}, double ${index.name})${attrs}`);
+    B.br(join);
+    B.startBlock(join);
+    const result = B.tmp();
+    B.line(`${result} = phi ${ty} [ ${fast}, %${fastLabel} ], [ ${slowValue}, %${slow} ]`);
+    return result;
+}
+/** `scr_arr_get_number`: a numeric element, or NaN for every missing,
+ * hole, or present-undefined slot (answered by the runtime). */
+export function emitDenseArrayNumber(host, array, index, indexExpr) {
+    return emitDenseArrayGet(host, array, index, indexExpr, "f64", { kind: "f64" }, "scr_arr_get_number", false);
+}
+/** `scr_arr_state` (as a double) or `scr_arr_has` (as an i1). Dense
+ * in-range indices answer from the state byte; everything else keeps the
+ * runtime query, including canonical indices at or past the length. */
+export function emitDenseArrayState(host, array, index, indexExpr, kind) {
+    const B = host.B;
+    const fn = kind === "state" ? "scr_arr_state" : "scr_arr_has";
+    const ty = kind === "state" ? "double" : "i1";
+    host.declare(`declare ${kind === "state" ? "double" : "zeroext i1"} @${fn}(ptr, double)`);
+    const slow = B.newLabel("arr.state.slow"), join = B.newLabel("arr.state.join");
+    const guard = emitDenseGuard(host, array, index, indexExpr, slow, true);
+    const state = loadState(host, guard);
+    const fast = B.tmp();
+    if (kind === "state")
+        B.line(`${fast} = uitofp i8 ${state} to double`);
+    else
+        B.line(`${fast} = icmp ne i8 ${state}, 0`);
+    const fastLabel = B.newLabel("arr.state.fast");
+    B.br(fastLabel);
+    B.startBlock(fastLabel);
+    B.br(join);
+    B.startBlock(slow);
+    const slowValue = B.tmp();
+    B.line(`${slowValue} = call ${ty} @${fn}(ptr ${array}, double ${index.name})${READ_FALLBACK}`);
+    B.br(join);
+    B.startBlock(join);
+    const result = B.tmp();
+    B.line(`${result} = phi ${ty} [ ${fast}, %${fastLabel} ], [ ${slowValue}, %${slow} ]`);
+    return result;
+}
+/** Element write with `scr_arr_set_*` semantics: the array takes the
+ * value's reference. A dense index stores the slot, marks it present, and
+ * extends the length when it lands at or past it; a replaced present
+ * reference is released after the new edge is published (a release can
+ * collect cycles). Every other index takes the unchanged runtime call. */
+export function emitDenseArraySet(host, array, index, indexExpr, acc, element, value) {
+    const B = host.B;
+    const ty = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
+    const setter = `scr_arr_set_${acc}`;
+    host.declare(`declare void @${setter}(ptr, double, ${acc === "bool" ? "i1 zeroext" : ty})`);
+    const call = (attrs) => B.line(`call void @${setter}(ptr ${array}, double ${index.name}, ${ty} ${value})${attrs}`);
+    if (acc === "ref" && !isRefCounted(element)) {
+        call("");
+        return;
+    }
+    const slow = B.newLabel("arr.set.slow"), join = B.newLabel("arr.set.join");
+    const guard = emitDenseGuard(host, array, index, indexExpr, slow, false);
+    const { offset, len } = guard;
+    const statePtr = statePointer(host, guard);
+    const valuePtr = valuePointer(host, guard);
+    let oldState = null;
+    let old = null;
+    if (acc === "ref") {
+        oldState = B.tmp();
+        old = B.tmp();
+        B.line(`${oldState} = load i8, ptr ${statePtr}${host.fieldAliasAttachment(statePtr)}`);
+        B.line(`${old} = load ptr, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    if (acc === "f64") {
+        B.line(`store double ${value}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    else if (acc === "bool") {
+        const bits = B.tmp();
+        B.line(`${bits} = zext i1 ${value} to i64`);
+        B.line(`store i64 ${bits}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    else {
+        B.line(`store ptr ${value}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    B.line(`store i8 ${SCR_ARR_VALUE}, ptr ${statePtr}${host.fieldAliasAttachment(statePtr)}`);
+    // Writes at or past the length extend it over the (hole) gap, exactly
+    // like the runtime's dense store.
+    const grows = B.tmp();
+    B.line(`${grows} = icmp uge ${host.sizeType} ${offset}, ${len}`);
+    const growLabel = B.newLabel("arr.set.grow"), storedLabel = B.newLabel("arr.set.stored");
+    B.condBr(grows, growLabel, storedLabel);
+    B.startBlock(growLabel);
+    const nextLen = B.tmp(), lenPtr = B.tmp();
+    B.line(`${nextLen} = add ${host.sizeType} ${offset}, 1`);
+    B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 1`);
+    host.markMemoryPointer(lenPtr, "array:header");
+    B.line(`store ${host.sizeType} ${nextLen}, ptr ${lenPtr}${host.fieldAliasAttachment(lenPtr)}`);
+    B.br(storedLabel);
+    B.startBlock(storedLabel);
+    if (acc === "ref" && oldState && old) {
+        const hadValue = B.tmp();
+        B.line(`${hadValue} = icmp eq i8 ${oldState}, ${SCR_ARR_VALUE}`);
+        const releaseLabel = B.newLabel("arr.set.release");
+        B.condBr(hadValue, releaseLabel, join);
+        B.startBlock(releaseLabel);
+        host.releaseValue(old, element);
+    }
+    B.br(join);
+    B.startBlock(slow);
+    call(" cold");
+    B.br(join);
+    B.startBlock(join);
+}
+/** `scr_arr_push_*` (the array takes the value's reference) returning the
+ * new length as a double. When `len < cap` the runtime's append is exactly
+ * a dense store at `len` plus `len + 1`: no sparse entry can exist past the
+ * length, nothing is released, and the dense capacity never exceeds the
+ * maximum index. A full array takes the unchanged (cold) runtime call,
+ * which grows storage. */
+export function emitDenseArrayPush(host, array, acc, value) {
+    const B = host.B;
+    const size = host.sizeType;
+    const ty = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
+    const pusher = `scr_arr_push_${acc}`;
+    host.declare(`declare double @${pusher}(ptr, ${acc === "bool" ? "i1 zeroext" : ty})`);
+    const header = (field) => {
+        const ptr = B.tmp();
+        B.line(`${ptr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 ${field}`);
+        host.markMemoryPointer(ptr, "array:header");
+        return ptr;
+    };
+    const lenPtr = header(1), len = B.tmp(), cap = B.tmp(), room = B.tmp();
+    B.line(`${len} = load ${size}, ptr ${lenPtr}${host.fieldAliasAttachment(lenPtr)}`);
+    const capPtr = header(2);
+    B.line(`${cap} = load ${size}, ptr ${capPtr}${host.fieldAliasAttachment(capPtr)}`);
+    B.line(`${room} = icmp ult ${size} ${len}, ${cap}`);
+    const fast = B.newLabel("arr.push.dense"), slow = B.newLabel("arr.push.slow"), join = B.newLabel("arr.push.join");
+    B.condBr(room, fast, slow);
+    B.startBlock(fast);
+    const dataPtr = header(7), data = B.tmp(), statesPtr = header(8), states = B.tmp();
+    B.line(`${data} = load ptr, ptr ${dataPtr}${host.fieldAliasAttachment(dataPtr)}`);
+    B.line(`${states} = load ptr, ptr ${statesPtr}${host.fieldAliasAttachment(statesPtr)}`);
+    const statePtr = statePointer(host, { offset: len, len, data, states });
+    const valuePtr = valuePointer(host, { offset: len, len, data, states });
+    if (acc === "f64") {
+        B.line(`store double ${value}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    else if (acc === "bool") {
+        const bits = B.tmp();
+        B.line(`${bits} = zext i1 ${value} to i64`);
+        B.line(`store i64 ${bits}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    else {
+        B.line(`store ptr ${value}, ptr ${valuePtr}${host.fieldAliasAttachment(valuePtr)}`);
+    }
+    B.line(`store i8 ${SCR_ARR_VALUE}, ptr ${statePtr}${host.fieldAliasAttachment(statePtr)}`);
+    const next = B.tmp(), fastValue = B.tmp();
+    B.line(`${next} = add nuw ${size} ${len}, 1`);
+    B.line(`store ${size} ${next}, ptr ${lenPtr}${host.fieldAliasAttachment(lenPtr)}`);
+    B.line(`${fastValue} = uitofp ${size} ${next} to double`);
+    B.br(join);
+    B.startBlock(slow);
+    const slowValue = B.tmp();
+    B.line(`${slowValue} = call double @${pusher}(ptr ${array}, ${ty} ${value}) cold`);
+    B.br(join);
+    B.startBlock(join);
+    const result = B.tmp();
+    B.line(`${result} = phi double [ ${fastValue}, %${fast} ], [ ${slowValue}, %${slow} ]`);
+    return result;
+}
+//# sourceMappingURL=dense-array-access.js.map