@scriptc/compiler 0.2.4 → 0.2.6

package/dist/backend/llvm/local-array-reads.test.js

@@ -1,8 +1,8 @@
 import { expect, test } from "vitest";
-import { BOOL, F64, VOID, UNDEFINED_T, arrayOf, funcOf } from "../../ir/ir.js";
+import { BOOL, F64, VOID, UNDEFINED_T, arrayOf, funcOf, } from "../../ir/ir.js";
 import { validateModule } from "../../ir/validate.js";
 import { emitLlvmModule } from "./emitter.js";
-import { findArrayPreservingFunctions, findLocalArrayReads, findCallArrayReads, OptionalArrayReads } from "./local-array-reads.js";
+import { findArrayPreservingFunctions, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.js";
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
 const loc = { file: "local-array.ts", start: 0, end: 0 };
 const element = { kind: "record", shapeId: "cell" };
@@ -10,29 +10,112 @@ const optional = { kind: "union", unionId: "optional" };
 const array = arrayOf(element);
 const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
 const num = (value) => ({ kind: "numLit", value, type: F64, loc });
-const params = [{ localId: "a", name: "a", type: array }, { localId: "i", name: "i", type: F64 }];
+const params = [
+    { localId: "a", name: "a", type: array },
+    { localId: "i", name: "i", type: F64 },
+];
 const unionValue = ref("value", optional);
-const narrow = { kind: "unionNarrow", unionId: "optional", tag: 0, value: unionValue, type: element, loc };
+const narrow = {
+    kind: "unionNarrow",
+    unionId: "optional",
+    tag: 0,
+    value: unionValue,
+    type: element,
+    loc,
+};
 function fixture() {
     const producer = {
-        name: "read", params, returnType: optional, locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })), loc,
-        body: [{ kind: "return", loc, value: {
-                    kind: "ternary", type: optional, loc,
-                    cond: { kind: "bin", op: "===", left: { kind: "arrayState", arr: ref("a", array), index: ref("i", F64), type: F64, loc }, right: num(1), type: BOOL, loc },
-                    then: { kind: "unionWrap", unionId: "optional", tag: 0, value: { kind: "arrayGet", arr: ref("a", array), index: ref("i", F64), type: element, loc }, type: optional, loc },
-                    else_: { kind: "unionWrap", unionId: "optional", tag: 1, value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: optional, loc },
-                } }],
+        name: "read",
+        params,
+        returnType: optional,
+        locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+        loc,
+        body: [
+            {
+                kind: "return",
+                loc,
+                value: {
+                    kind: "ternary",
+                    type: optional,
+                    loc,
+                    cond: {
+                        kind: "bin",
+                        op: "===",
+                        left: {
+                            kind: "arrayState",
+                            arr: ref("a", array),
+                            index: ref("i", F64),
+                            type: F64,
+                            loc,
+                        },
+                        right: num(1),
+                        type: BOOL,
+                        loc,
+                    },
+                    then: {
+                        kind: "unionWrap",
+                        unionId: "optional",
+                        tag: 0,
+                        value: {
+                            kind: "arrayGet",
+                            arr: ref("a", array),
+                            index: ref("i", F64),
+                            type: element,
+                            loc,
+                        },
+                        type: optional,
+                        loc,
+                    },
+                    else_: {
+                        kind: "unionWrap",
+                        unionId: "optional",
+                        tag: 1,
+                        value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                        type: optional,
+                        loc,
+                    },
+                },
+            },
+        ],
     };
     const work = {
-        name: "work", params, returnType: F64, loc,
+        name: "work",
+        params,
+        returnType: F64,
+        loc,
         locals: [...producer.locals, { id: "value", name: "value", type: optional, mutable: false }],
         body: [
-            { kind: "varDecl", localId: "value", init: { kind: "call", callee: "read", args: [ref("a", array), ref("i", F64)], type: optional, loc }, loc },
-            { kind: "return", value: { kind: "recordGet", obj: narrow, shapeId: "cell", field: "x", type: F64, loc }, loc },
+            {
+                kind: "varDecl",
+                localId: "value",
+                init: {
+                    kind: "call",
+                    callee: "read",
+                    args: [ref("a", array), ref("i", F64)],
+                    type: optional,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "return",
+                value: { kind: "recordGet", obj: narrow, shapeId: "cell", field: "x", type: F64, loc },
+                loc,
+            },
+        ],
+    };
+    return {
+        irVersion: 14,
+        sourceFile: loc.file,
+        entry: "main",
+        records: [{ id: "cell", fields: [{ name: "x", type: F64 }] }],
+        unions: [{ id: "optional", arms: [element, UNDEFINED_T] }],
+        functions: [
+            { name: "main", params: [], returnType: VOID, locals: [], body: [], loc },
+            producer,
+            work,
         ],
     };
-    return { irVersion: 13, sourceFile: loc.file, entry: "main", records: [{ id: "cell", fields: [{ name: "x", type: F64 }] }], unions: [{ id: "optional", arms: [element, UNDEFINED_T] }],
-        functions: [{ name: "main", params: [], returnType: VOID, locals: [], body: [], loc }, producer, work] };
 }
 function candidates(mod) {
     const functions = new Map(mod.functions.map((f) => [f.name, f]));
@@ -56,9 +139,41 @@ test("private optional array results use local tags and borrowed payloads on bot
         expect(body).not.toContain("@sc_rrelease_");
     }
 });
+test("unchanged let bindings keep optional array payloads private", () => {
+    const mod = fixture();
+    mod.functions[2].locals[2].mutable = true;
+    expect(candidates(mod).get("value")?.borrow).toBe(true);
+    expect(workBody(mod)).not.toContain("@sc_rretain_");
+});
+test("preserving loops borrow from local array owners despite unrelated mutation", () => {
+    const mod = fixture();
+    const work = mod.functions[2];
+    work.locals[2].mutable = true;
+    work.body = [
+        { kind: "arraySetLength", arr: ref("a", array), length: num(1), loc },
+        { kind: "for", init: null, cond: null, update: null, body: work.body, loc },
+    ];
+    expect(candidates(mod).get("value")?.borrow).not.toBe(true);
+    for (const pointerBits of [32, 64]) {
+        const body = workBody(mod, pointerBits);
+        expect(body).toContain("@scr_arr_peek_ref");
+        expect(body).not.toContain("@sc_rretain_");
+        expect(body).not.toContain("@sc_rrelease_");
+    }
+    const loop = work.body[1];
+    if (loop.kind !== "for")
+        throw new Error("expected loop");
+    loop.body.splice(1, 0, { kind: "arraySetLength", arr: ref("a", array), length: num(0), loc });
+    expect(workBody(mod)).toContain("@sc_rretain_");
+});
 test("array mutation preserves a separate payload owner and exceptional cleanup", () => {
     const mod = fixture();
-    mod.functions[2].body.splice(1, 0, { kind: "arraySetLength", arr: ref("a", array), length: num(0), loc });
+    mod.functions[2].body.splice(1, 0, {
+        kind: "arraySetLength",
+        arr: ref("a", array),
+        length: num(0),
+        loc,
+    });
     expect(validateModule(mod)).toEqual([]);
     expect(candidates(mod).get("value")?.borrow).not.toBe(true);
     const body = workBody(mod);
@@ -66,22 +181,50 @@ test("array mutation preserves a separate payload owner and exceptional cleanup"
     expect(body).toContain("@sc_rrelease_");
     expect(body).not.toContain("@scr_union_release");
 });
-test.each(["alias", "capture", "assign", "boxed", "tdz", "mutable", "duplicate", "async", "effectful producer"])("keeps %s optional boxes on the general path", (reason) => {
+test("replacing an array parameter keeps the earlier element independently owned", () => {
+    const mod = fixture();
+    const work = mod.functions[2];
+    work.locals[0] = { ...work.locals[0], mutable: true };
+    work.params = [...work.params, { localId: "replacement", name: "replacement", type: array }];
+    work.locals.push({ id: "replacement", name: "replacement", type: array, mutable: false });
+    work.body.splice(1, 0, { kind: "assign", localId: "a", value: ref("replacement", array), loc });
+    expect(validateModule(mod)).toEqual([]);
+    const functions = new Map(mod.functions.map((f) => [f.name, f]));
+    expect(findArrayPreservingFunctions(functions, new Map(mod.unions.map((u) => [u.id, u]))).has("work")).toBe(true);
+    expect(candidates(mod).get("value")?.borrow).not.toBe(true);
+    for (const bits of [32, 64]) {
+        const body = workBody(mod, bits);
+        expect(body).toContain("@sc_rretain_");
+        expect(body).toContain("@sc_rrelease_");
+    }
+});
+test.each([
+    "alias",
+    "capture",
+    "assign",
+    "boxed",
+    "tdz",
+    "duplicate",
+    "async",
+    "effectful producer",
+])("keeps %s optional boxes on the general path", (reason) => {
     const mod = fixture();
     const fn = mod.functions[2];
     const local = fn.locals[2];
     if (reason === "alias")
         fn.body.push({ kind: "return", value: unionValue, loc });
     if (reason === "capture")
-        fn.body.push({ kind: "exprStmt", expr: { kind: "closure", fnName: "capture", captures: ["value"], type: funcOf([], F64), loc }, loc });
+        fn.body.push({
+            kind: "exprStmt",
+            expr: { kind: "closure", fnName: "capture", captures: ["value"], type: funcOf([], F64), loc },
+            loc,
+        });
     if (reason === "assign")
         fn.body.push({ kind: "assign", localId: "value", value: unionValue, loc });
     if (reason === "boxed")
         local.boxed = true;
     if (reason === "tdz")
         local.tdz = true;
-    if (reason === "mutable")
-        local.mutable = true;
     if (reason === "duplicate")
         fn.body.push(fn.body[0]);
     if (reason === "async")
@@ -104,15 +247,28 @@ test("unknown calls and reference stores disable array borrowing", () => {
 });
 function scalarHelper(name, callee) {
     return {
-        name, params: [{ localId: "n", name: "n", type: F64 }], returnType: F64, loc,
+        name,
+        params: [{ localId: "n", name: "n", type: F64 }],
+        returnType: F64,
+        loc,
         locals: [{ id: "n", name: "n", type: F64, mutable: false }],
-        body: [{ kind: "return", loc, value: callee
+        body: [
+            {
+                kind: "return",
+                loc,
+                value: callee
                     ? { kind: "call", callee, args: [ref("n", F64)], type: F64, loc }
-                    : { kind: "bin", op: "+", left: ref("n", F64), right: num(1), type: F64, loc } }],
+                    : { kind: "bin", op: "+", left: ref("n", F64), right: num(1), type: F64, loc },
+            },
+        ],
     };
 }
 function callHelper(mod, callee, argument = num(2)) {
-    mod.functions[2].body.splice(1, 0, { kind: "exprStmt", loc, expr: { kind: "call", callee, args: [argument], type: F64, loc } });
+    mod.functions[2].body.splice(1, 0, {
+        kind: "exprStmt",
+        loc,
+        expr: { kind: "call", callee, args: [argument], type: F64, loc },
+    });
 }
 test("borrows array payloads across direct and transitive scalar helpers", () => {
     const mod = fixture();
@@ -137,6 +293,8 @@ test("propagates reference mutation through a recursive call group", () => {
     expect(candidates(mod).get("value")?.borrow).toBe(true);
     inner.locals.push({ id: "owned", name: "owned", type: array, mutable: true });
     inner.body.unshift({ kind: "assign", localId: "owned", value: ref("owned", array), loc });
+    expect(candidates(mod).get("value")?.borrow).toBe(true);
+    inner.body.unshift({ kind: "arraySetLength", arr: ref("owned", array), length: num(0), loc });
     expect(candidates(mod).get("value")?.borrow).not.toBe(true);
     expect(workBody(mod)).toContain("@sc_rretain_");
 });
@@ -146,9 +304,23 @@ test.each(["unknown", "callback", "async", "capture", "reference store"])("rejec
     mod.functions.push(scalarHelper("outer", "inner"), inner);
     callHelper(mod, "outer");
     if (effect === "unknown")
-        inner.body[0] = { kind: "return", loc, value: { kind: "call", callee: "unavailable", args: [], type: F64, loc } };
+        inner.body[0] = {
+            kind: "return",
+            loc,
+            value: { kind: "call", callee: "unavailable", args: [], type: F64, loc },
+        };
     if (effect === "callback")
-        inner.body[0] = { kind: "return", loc, value: { kind: "callValue", callee: ref("callback", funcOf([], F64)), args: [], type: F64, loc } };
+        inner.body[0] = {
+            kind: "return",
+            loc,
+            value: {
+                kind: "callValue",
+                callee: ref("callback", funcOf([], F64)),
+                args: [],
+                type: F64,
+                loc,
+            },
+        };
     if (effect === "async")
         inner.async = true;
     if (effect === "capture")
@@ -160,8 +332,13 @@ test.each(["unknown", "callback", "async", "capture", "reference store"])("rejec
 test("checks side effects in arguments even when the callee preserves references", () => {
     const mod = fixture();
     mod.functions.push(scalarHelper("helper"));
-    callHelper(mod, "helper", { kind: "seqExpr", loc, type: F64,
-        stmts: [{ kind: "arraySetLength", arr: ref("a", array), length: num(0), loc }], result: num(0) });
+    callHelper(mod, "helper", {
+        kind: "seqExpr",
+        loc,
+        type: F64,
+        stmts: [{ kind: "arraySetLength", arr: ref("a", array), length: num(0), loc }],
+        result: num(0),
+    });
     expect(validateModule(mod)).toEqual([]);
     expect(candidates(mod).get("value")?.borrow).not.toBe(true);
     expect(workBody(mod)).toContain("@sc_rretain_");
@@ -176,16 +353,28 @@ test("iteratively propagates an unsafe leaf through a long call chain", () => {
 });
 function projectionHelper(name, callee) {
     return {
-        name, params: [{ localId: "value", name: "value", type: optional }], returnType: F64, loc,
+        name,
+        params: [{ localId: "value", name: "value", type: optional }],
+        returnType: F64,
+        loc,
         locals: [{ id: "value", name: "value", type: optional, mutable: true }],
-        body: [{ kind: "return", loc, value: callee
+        body: [
+            {
+                kind: "return",
+                loc,
+                value: callee
                     ? { kind: "call", callee, args: [unionValue], type: F64, loc }
-                    : { kind: "recordGet", obj: narrow, shapeId: "cell", field: "x", type: F64, loc } }],
+                    : { kind: "recordGet", obj: narrow, shapeId: "cell", field: "x", type: F64, loc },
+            },
+        ],
     };
 }
 function passOptional(mod, callee) {
-    mod.functions[2].body[1] = { kind: "return", loc,
-        value: { kind: "call", callee, args: [unionValue], type: F64, loc } };
+    mod.functions[2].body[1] = {
+        kind: "return",
+        loc,
+        value: { kind: "call", callee, args: [unionValue], type: F64, loc },
+    };
 }
 test("keeps optional array boxes local across transitive projection helpers", () => {
     const mod = fixture();
@@ -210,8 +399,11 @@ test("a mutating helper preserves the local box but requires its payload owner",
     helper.locals.push({ id: "items", name: "items", type: array, mutable: false });
     helper.body.unshift({ kind: "arraySetLength", arr: ref("items", array), length: num(0), loc });
     mod.functions.push(helper);
-    mod.functions[2].body[1] = { kind: "return", loc,
-        value: { kind: "call", callee: "helper", args: [unionValue, ref("a", array)], type: F64, loc } };
+    mod.functions[2].body[1] = {
+        kind: "return",
+        loc,
+        value: { kind: "call", callee: "helper", args: [unionValue, ref("a", array)], type: F64, loc },
+    };
     expect(validateModule(mod)).toEqual([]);
     expect(candidates(mod).get("value")?.borrow).not.toBe(true);
     const body = workBody(mod);
@@ -240,10 +432,18 @@ test("a later mutating argument snapshots the payload before entering the helper
     helper.params.push({ localId: "count", name: "count", type: F64 });
     helper.locals.push({ id: "count", name: "count", type: F64, mutable: true });
     mod.functions.push(helper);
-    const later = { kind: "seqExpr", loc, type: F64,
-        stmts: [{ kind: "arraySetLength", arr: ref("a", array), length: num(0), loc }], result: num(1) };
-    mod.functions[2].body[1] = { kind: "return", loc,
-        value: { kind: "call", callee: "helper", args: [unionValue, later], type: F64, loc } };
+    const later = {
+        kind: "seqExpr",
+        loc,
+        type: F64,
+        stmts: [{ kind: "arraySetLength", arr: ref("a", array), length: num(0), loc }],
+        result: num(1),
+    };
+    mod.functions[2].body[1] = {
+        kind: "return",
+        loc,
+        value: { kind: "call", callee: "helper", args: [unionValue, later], type: F64, loc },
+    };
     expect(validateModule(mod)).toEqual([]);
     expect(candidates(mod).get("value")?.borrow).not.toBe(true);
     const body = workBody(mod);
@@ -254,15 +454,42 @@ test("a later mutating argument snapshots the payload before entering the helper
 function immediateFixture() {
     const module = fixture();
     const consume = {
-        name: "consume", loc, params: [{ localId: "value", name: "value", type: optional }],
-        locals: [{ id: "value", name: "value", type: optional, mutable: true }], returnType: F64,
-        body: [{ kind: "return", value: { kind: "recordGet", obj: narrow, shapeId: "cell", field: "x", type: F64, loc }, loc }],
+        name: "consume",
+        loc,
+        params: [{ localId: "value", name: "value", type: optional }],
+        locals: [{ id: "value", name: "value", type: optional, mutable: true }],
+        returnType: F64,
+        body: [
+            {
+                kind: "return",
+                value: { kind: "recordGet", obj: narrow, shapeId: "cell", field: "x", type: F64, loc },
+                loc,
+            },
+        ],
     };
     const work = module.functions[2];
     work.locals = work.locals.filter((local) => local.id !== "value");
-    work.body = [{ kind: "return", value: {
-                kind: "call", callee: "consume", args: [{ kind: "call", callee: "read", args: [ref("a", array), ref("i", F64)], type: optional, loc }], type: F64, loc,
-            }, loc }];
+    work.body = [
+        {
+            kind: "return",
+            value: {
+                kind: "call",
+                callee: "consume",
+                args: [
+                    {
+                        kind: "call",
+                        callee: "read",
+                        args: [ref("a", array), ref("i", F64)],
+                        type: optional,
+                        loc,
+                    },
+                ],
+                type: F64,
+                loc,
+            },
+            loc,
+        },
+    ];
     module.functions.push(consume);
     return module;
 }
@@ -301,9 +528,13 @@ test("a later argument that removes an array edge keeps an independent payload o
     const consume = module.functions[3];
     consume.params.push({ localId: "other", name: "other", type: F64 });
     consume.locals.push({ id: "other", name: "other", type: F64, mutable: false });
-    immediateCall(module).args.push({ kind: "seqExpr", stmts: [
-            { kind: "arraySetLength", arr: ref("a", array), length: num(0), loc },
-        ], result: num(1), type: F64, loc });
+    immediateCall(module).args.push({
+        kind: "seqExpr",
+        stmts: [{ kind: "arraySetLength", arr: ref("a", array), length: num(0), loc }],
+        result: num(1),
+        type: F64,
+        loc,
+    });
     const read = immediateCall(module).args[0];
     expect(immediateFacts(module).get(read)?.borrow).not.toBe(true);
     expect(validateModule(module)).toEqual([]);
@@ -351,17 +582,36 @@ test("async and generator callers keep their established suspension representati
         if (suspend === "async")
             work.async = true;
         else
-            work.generator = { yieldT: F64, nextT: F64, resultType: { kind: "record", shapeId: "result" } };
+            work.generator = {
+                yieldT: F64,
+                nextT: F64,
+                resultType: { kind: "record", shapeId: "result" },
+            };
         expect(immediateFacts(module).size).toBe(0);
     }
 });
 test("indirect consumers do not receive immediate stack unions", () => {
     const module = immediateFixture();
     const call = immediateCall(module);
-    module.functions[2].body = [{ kind: "return", loc, value: {
-                kind: "callValue", callee: { kind: "closure", fnName: "consume", captures: [], type: funcOf([optional], F64), loc },
-                args: call.args, type: F64, loc,
-            } }];
+    module.functions[2].body = [
+        {
+            kind: "return",
+            loc,
+            value: {
+                kind: "callValue",
+                callee: {
+                    kind: "closure",
+                    fnName: "consume",
+                    captures: [],
+                    type: funcOf([optional], F64),
+                    loc,
+                },
+                args: call.args,
+                type: F64,
+                loc,
+            },
+        },
+    ];
     expect(immediateFacts(module).size).toBe(0);
     expect(workBody(module)).toContain("@sc_bf_read");
 });
@@ -370,23 +620,43 @@ test("each immediate argument has separate tag and payload storage", () => {
     const consume = module.functions[3];
     consume.params.push({ localId: "second", name: "second", type: optional });
     consume.locals.push({ id: "second", name: "second", type: optional, mutable: false });
-    consume.body.unshift({ kind: "exprStmt", expr: {
-            kind: "unionIsTag", value: ref("second", optional), unionId: "optional", tag: 1, negated: false, type: BOOL, loc,
-        }, loc });
-    immediateCall(module).args.push({ kind: "call", callee: "read", args: [ref("a", array), num(1)], type: optional, loc });
+    consume.body.unshift({
+        kind: "exprStmt",
+        expr: {
+            kind: "unionIsTag",
+            value: ref("second", optional),
+            unionId: "optional",
+            tag: 1,
+            negated: false,
+            type: BOOL,
+            loc,
+        },
+        loc,
+    });
+    immediateCall(module).args.push({
+        kind: "call",
+        callee: "read",
+        args: [ref("a", array), num(1)],
+        type: optional,
+        loc,
+    });
     expect(immediateFacts(module).size).toBe(2);
     const ir = workBody(module);
     expect(ir.match(/alloca %ScrUnion/g)).toHaveLength(2);
     expect(ir.match(/@scr_arr_peek_ref/g)).toHaveLength(2);
     expect(ir).not.toContain("@sc_bf_read");
 });
-test("throwing later arguments release a completed read snapshot", () => {
+test("throwing later arguments borrow preserved payloads and release mutable snapshots", () => {
     const module = immediateFixture();
     const consume = module.functions[3];
     consume.params.push({ localId: "other", name: "other", type: F64 });
     consume.locals.push({ id: "other", name: "other", type: F64, mutable: false });
     const failure = {
-        name: "failure", params: [], locals: [], returnType: F64, loc,
+        name: "failure",
+        params: [],
+        locals: [],
+        returnType: F64,
+        loc,
         body: [{ kind: "throw", value: num(7), loc }],
     };
     module.functions.push(failure);
@@ -395,7 +665,22 @@ test("throwing later arguments release a completed read snapshot", () => {
     const later = ir.indexOf("@sc_f_failure");
     expect(later).toBeGreaterThan(0);
     expect(ir.slice(later)).toContain("@scr_exc_pending");
-    expect(ir.slice(later)).toContain("@sc_rrelease_");
+    expect(ir.slice(later)).not.toContain("@sc_rrelease_");
+    failure.params.push({ localId: "items", name: "items", type: array });
+    failure.locals.push({ id: "items", name: "items", type: array, mutable: false });
+    failure.body.unshift({ kind: "arraySetLength", arr: ref("items", array), length: num(0), loc });
+    immediateCall(module).args[1] = {
+        kind: "call",
+        callee: "failure",
+        args: [ref("a", array)],
+        type: F64,
+        loc,
+    };
+    const owned = workBody(module);
+    const mutation = owned.indexOf("@sc_bf_failure");
+    expect(mutation).toBeGreaterThan(0);
+    expect(owned.slice(mutation)).toContain("@scr_exc_pending");
+    expect(owned.slice(mutation)).toContain("@sc_rrelease_");
 });
 test("a temporary array receiver lives through its indexed lookup", () => {
     const module = immediateFixture();
@@ -418,7 +703,13 @@ test("helper recognition is reused by multiple sites and isolated to one finaliz
     const helper = module.functions[1];
     const original = helper.body;
     let bodyReads = 0;
-    Object.defineProperty(helper, "body", { configurable: true, get: () => { bodyReads++; return original; } });
+    Object.defineProperty(helper, "body", {
+        configurable: true,
+        get: () => {
+            bodyReads++;
+            return original;
+        },
+    });
     for (let i = 0; i < 100; i++)
         expect(index.get(read)?.presentTag).toBe(0);
     expect(bodyReads).toBe(0);
@@ -443,4 +734,45 @@ test("recognition checks the helper result representation as well as its body",
     const unions = new Map(module.unions.map((union) => [union.id, union]));
     expect(new OptionalArrayReads(functions, unions).get(immediateCall(module).args[0])).toBeNull();
 });
+test("lowered inline reads share the sparse-aware optional lookup", () => {
+    const mod = fixture();
+    const source = mod.functions[1].body[0];
+    const local = mod.functions[2].body[0];
+    if (source.kind !== "return" || !source.value || local.kind !== "varDecl")
+        throw new Error("missing optional read");
+    local.init = structuredClone(source.value);
+    expect(candidates(mod).get("value")?.borrow).toBe(true);
+    for (const bits of [32, 64]) {
+        const ir = workBody(mod, bits);
+        expect(ir).toContain("local.array.dense");
+        expect(ir).toContain("@scr_arr_peek_ref");
+        expect(ir).not.toContain("@scr_arr_get_ref");
+        expect(ir).not.toContain("@scr_union_new_ref");
+    }
+});
+test.each(["different index", "different array", "effectful operand", "different state"])("inline lookup refuses a %s", (reason) => {
+    const mod = fixture();
+    const ret = mod.functions[1].body[0];
+    if (ret.kind !== "return" || ret.value?.kind !== "ternary")
+        throw new Error("missing read");
+    const value = ret.value;
+    if (value.cond.kind !== "bin" ||
+        value.cond.left.kind !== "arrayState" ||
+        value.then.kind !== "unionWrap" ||
+        value.then.value.kind !== "arrayGet")
+        throw new Error("missing shape");
+    if (reason === "different index")
+        value.then.value.index = num(2);
+    else if (reason === "different array")
+        value.then.value.arr = ref("other", array);
+    else if (reason === "different state")
+        value.cond.right = num(2);
+    else {
+        const next = { kind: "incDec", localId: "i", op: "+", prefix: false, type: F64, loc };
+        value.cond.left.index = next;
+        value.then.value.index = next;
+    }
+    const reads = new OptionalArrayReads(new Map(), new Map(mod.unions.map((u) => [u.id, u])));
+    expect(reads.get(value)).toBeNull();
+});
 //# sourceMappingURL=local-array-reads.test.js.map