redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/optimizer/interprocedural.test.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const interprocedural_1 = require("../../optimizer/interprocedural");
+function mkMod(functions) {
+    return { functions, namespace: 'test', objective: '__test' };
+}
+function mkFn(name, params, blocks) {
+    return {
+        name,
+        params: params.map(p => ({ name: p, isMacroParam: false })),
+        blocks,
+        entry: 'entry',
+        isMacro: false,
+    };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('interproceduralConstProp', () => {
+    test('specializes callee when all args are constants', () => {
+        // fn add(a, b) { return a + b }
+        // fn main() { call add(3, 4) }
+        const addFn = mkFn('test:add', ['a', 'b'], [
+            mkBlock('entry', [
+                { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('result') }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:add', args: [c(3), c(4)] },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const mod = mkMod([mainFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        // Should have a specialized function
+        const specializedName = 'test:add__const_3_4';
+        const specialized = result.functions.find(f => f.name === specializedName);
+        expect(specialized).toBeDefined();
+        // Specialized function should have no params
+        expect(specialized.params).toHaveLength(0);
+        // Specialized function should have constant-folded result: add(3,4) → 7
+        const entry = specialized.blocks[0];
+        const returnInstr = entry.term;
+        // After const fold, the add(3,4) becomes const 7, and return references it
+        const resultInstr = entry.instrs.find(i => i.kind === 'const' && i.value === 7);
+        expect(resultInstr).toBeDefined();
+    });
+    test('rewrites call site to use specialized function', () => {
+        const addFn = mkFn('test:add', ['a', 'b'], [
+            mkBlock('entry', [
+                { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('result') }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:add', args: [c(3), c(4)] },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const mod = mkMod([mainFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const callInstr = main.blocks[0].instrs.find(i => i.kind === 'call');
+        expect(callInstr.fn).toBe('test:add__const_3_4');
+        expect(callInstr.args).toHaveLength(0);
+    });
+    test('does not specialize when args are not all constants', () => {
+        const addFn = mkFn('test:add', ['a', 'b'], [
+            mkBlock('entry', [
+                { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('result') }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:add', args: [t('x'), c(4)] },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const mod = mkMod([mainFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        // No specialization created
+        expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false);
+    });
+    test('does not specialize macro functions', () => {
+        const macroFn = {
+            name: 'test:mfn',
+            params: [{ name: 'a', isMacroParam: true }],
+            blocks: [mkBlock('entry', [], { kind: 'return', value: null })],
+            entry: 'entry',
+            isMacro: true,
+        };
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: null, fn: 'test:mfn', args: [c(5)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mkMod([mainFn, macroFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false);
+    });
+    test('does not specialize external functions (not in module)', () => {
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: null, fn: 'external:fn', args: [c(1), c(2)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mkMod([mainFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        expect(result.functions).toHaveLength(1);
+    });
+    test('mangles negative constant args with n prefix', () => {
+        const addFn = mkFn('test:add', ['a'], [
+            mkBlock('entry', [
+                { kind: 'neg', dst: 'result', src: t('a') },
+            ], { kind: 'return', value: t('result') }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:add', args: [c(-5)] },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const mod = mkMod([mainFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        const specialized = result.functions.find(f => f.name === 'test:add__const_n5');
+        expect(specialized).toBeDefined();
+    });
+    test('does not create duplicate specializations', () => {
+        const addFn = mkFn('test:add', ['a', 'b'], [
+            mkBlock('entry', [
+                { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('result') }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:add', args: [c(1), c(2)] },
+                { kind: 'call', dst: 't1', fn: 'test:add', args: [c(1), c(2)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mkMod([mainFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        const specialized = result.functions.filter(f => f.name === 'test:add__const_1_2');
+        expect(specialized).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=interprocedural.test.js.map

package/dist/src/__tests__/optimizer/lir/const_imm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer/lir/const_imm.test.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const const_imm_1 = require("../../../optimizer/lir/const_imm");
+const obj = '__test';
+function mkSlot(player) {
+    return { player, obj };
+}
+function mkFn(instructions) {
+    return { name: 'test', instructions, isMacro: false, macroParams: [] };
+}
+describe('constant immediate folding', () => {
+    test('folds score_set + score_add into scoreboard players add', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: 'scoreboard players add $x __test 5',
+        });
+    });
+    test('folds score_set + score_sub into scoreboard players remove', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_3'), value: 3 },
+            { kind: 'score_sub', dst: mkSlot('$y'), src: mkSlot('$__const_3') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: 'scoreboard players remove $y __test 3',
+        });
+    });
+    test('folds negative constant add into remove', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_-7'), value: -7 },
+            { kind: 'score_add', dst: mkSlot('$z'), src: mkSlot('$__const_-7') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: 'scoreboard players remove $z __test 7',
+        });
+    });
+    test('folds negative constant sub into add', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_-2'), value: -2 },
+            { kind: 'score_sub', dst: mkSlot('$w'), src: mkSlot('$__const_-2') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: 'scoreboard players add $w __test 2',
+        });
+    });
+    test('eliminates add 0 (no-op)', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_0'), value: 0 },
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_0') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(0);
+    });
+    test('eliminates sub 0 (no-op)', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_0'), value: 0 },
+            { kind: 'score_sub', dst: mkSlot('$x'), src: mkSlot('$__const_0') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(0);
+    });
+    test('does not fold when const slot has multiple uses', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+            { kind: 'score_add', dst: mkSlot('$y'), src: mkSlot('$__const_5') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        // Should not fold because $__const_5 is used twice
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('does not fold non-const slots', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$temp'), value: 5 },
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$temp') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(2);
+    });
+    test('does not fold when instructions are not adjacent', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+            { kind: 'call', fn: 'test:foo' },
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('does not fold score_mul (no single MC command)', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+            { kind: 'score_mul', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(2);
+    });
+    test('folds multiple independent pairs', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$__const_3'), value: 3 },
+            { kind: 'score_add', dst: mkSlot('$a'), src: mkSlot('$__const_3') },
+            { kind: 'score_set', dst: mkSlot('$__const_7'), value: 7 },
+            { kind: 'score_sub', dst: mkSlot('$b'), src: mkSlot('$__const_7') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: 'scoreboard players add $a __test 3',
+        });
+        expect(result.instructions[1]).toEqual({
+            kind: 'raw',
+            cmd: 'scoreboard players remove $b __test 7',
+        });
+    });
+    test('returns same reference when nothing changed', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$x'), value: 1 },
+            { kind: 'return_value', slot: mkSlot('$x') },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result).toBe(fn);
+    });
+});
+//# sourceMappingURL=const_imm.test.js.map

package/dist/src/__tests__/optimizer/lir/dead_slot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer/lir/dead_slot.test.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dead_slot_1 = require("../../../optimizer/lir/dead_slot");
+const obj = '__test';
+function mkSlot(player) {
+    return { player, obj };
+}
+function mkFn(name, instructions) {
+    return { name, instructions, isMacro: false, macroParams: [] };
+}
+function mkModule(functions) {
+    return { functions, namespace: 'test', objective: obj };
+}
+describe('dead slot elimination', () => {
+    test('removes score_set when dst is never read', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$dead'), value: 42 },
+            { kind: 'score_set', dst: mkSlot('$live'), value: 1 },
+            { kind: 'return_value', slot: mkSlot('$live') },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result.instructions[0]).toEqual({ kind: 'score_set', dst: mkSlot('$live'), value: 1 });
+    });
+    test('removes score_copy when dst is never read', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$src'), value: 5 },
+            { kind: 'score_copy', dst: mkSlot('$dead'), src: mkSlot('$src') },
+            { kind: 'return_value', slot: mkSlot('$src') },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result.instructions.some(i => i.kind === 'score_copy')).toBe(false);
+    });
+    test('keeps writes to $ret slot', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$ret'), value: 10 },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(1);
+    });
+    test('keeps writes to $ret_field slots', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$ret_x'), value: 10 },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(1);
+    });
+    test('keeps writes to $p0 parameter slots', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$p0'), value: 3 },
+            { kind: 'score_set', dst: mkSlot('$p1'), value: 7 },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(2);
+    });
+    test('keeps non-pure-write instructions even if dst is unread', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$y') },
+            { kind: 'call', fn: 'test:foo' },
+            { kind: 'raw', cmd: 'say hello' },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('keeps score_set when dst is read by score_add', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$t'), value: 5 },
+            { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$t') },
+            { kind: 'return_value', slot: mkSlot('$x') },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('returns same reference when nothing removed', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$x'), value: 1 },
+            { kind: 'return_value', slot: mkSlot('$x') },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result).toBe(fn);
+    });
+    test('handles call_if_matches slot reads', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$cond'), value: 1 },
+            { kind: 'call_if_matches', fn: 'test:branch', slot: mkSlot('$cond'), range: '1' },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(2);
+    });
+    test('keeps score_set when slot is referenced in raw command', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$cond'), value: 0 },
+            { kind: 'raw', cmd: 'execute if score $a __test > $b __test run scoreboard players set $cond __test 1' },
+            { kind: 'call_if_matches', fn: 'test:branch', slot: mkSlot('$cond'), range: '1' },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        // $cond is referenced in the raw command — must not be removed
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('handles call_if_score slot reads', () => {
+        const fn = mkFn('test', [
+            { kind: 'score_set', dst: mkSlot('$a'), value: 1 },
+            { kind: 'score_set', dst: mkSlot('$b'), value: 2 },
+            { kind: 'call_if_score', fn: 'test:cmp', a: mkSlot('$a'), op: 'lt', b: mkSlot('$b') },
+        ]);
+        const result = (0, dead_slot_1.deadSlotElim)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+});
+describe('dead slot elimination (module-level)', () => {
+    test('removes slot dead across all functions', () => {
+        const mod = mkModule([
+            mkFn('fn1', [
+                { kind: 'score_set', dst: mkSlot('$dead'), value: 99 },
+                { kind: 'score_set', dst: mkSlot('$live'), value: 1 },
+            ]),
+            mkFn('fn2', [
+                { kind: 'return_value', slot: mkSlot('$live') },
+            ]),
+        ]);
+        const result = (0, dead_slot_1.deadSlotElimModule)(mod);
+        expect(result.functions[0].instructions).toHaveLength(1);
+        expect(result.functions[0].instructions[0]).toEqual({
+            kind: 'score_set', dst: mkSlot('$live'), value: 1,
+        });
+    });
+    test('keeps slot read in another function', () => {
+        const mod = mkModule([
+            mkFn('fn1', [
+                { kind: 'score_set', dst: mkSlot('$shared'), value: 5 },
+            ]),
+            mkFn('fn2', [
+                { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$shared') },
+            ]),
+        ]);
+        const result = (0, dead_slot_1.deadSlotElimModule)(mod);
+        expect(result.functions[0].instructions).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=dead_slot.test.js.map

package/dist/src/__tests__/optimizer/lir/peephole.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer/lir/peephole.test.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const peephole_1 = require("../../../optimizer/lir/peephole");
+const obj = '__test';
+function mkSlot(player) {
+    return { player, obj };
+}
+function mkFn(instructions) {
+    return { name: 'test', instructions, isMacro: false, macroParams: [] };
+}
+describe('execute store peephole', () => {
+    test('merges call_context + score_set into store_cmd_to_score', () => {
+        const callCtx = {
+            kind: 'call_context',
+            fn: 'ns:myfn',
+            subcommands: [{ kind: 'as', selector: '@s' }],
+        };
+        const fn = mkFn([
+            callCtx,
+            { kind: 'score_set', dst: mkSlot('$result'), value: 1 },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'store_cmd_to_score',
+            dst: mkSlot('$result'),
+            cmd: callCtx,
+        });
+    });
+    test('merges call_context + score_set with zero value', () => {
+        const callCtx = {
+            kind: 'call_context',
+            fn: 'ns:check',
+            subcommands: [{ kind: 'at_self' }],
+        };
+        const fn = mkFn([
+            callCtx,
+            { kind: 'score_set', dst: mkSlot('$flag'), value: 0 },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0].kind).toBe('store_cmd_to_score');
+    });
+    test('does not merge when call_context and score_set are not adjacent', () => {
+        const fn = mkFn([
+            {
+                kind: 'call_context',
+                fn: 'ns:myfn',
+                subcommands: [{ kind: 'as', selector: '@s' }],
+            },
+            { kind: 'call', fn: 'ns:other' },
+            { kind: 'score_set', dst: mkSlot('$result'), value: 1 },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('does not merge plain call + score_set', () => {
+        const fn = mkFn([
+            { kind: 'call', fn: 'ns:myfn' },
+            { kind: 'score_set', dst: mkSlot('$result'), value: 1 },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(2);
+    });
+    test('does not merge call_context + score_copy', () => {
+        const fn = mkFn([
+            {
+                kind: 'call_context',
+                fn: 'ns:myfn',
+                subcommands: [{ kind: 'as', selector: '@s' }],
+            },
+            { kind: 'score_copy', dst: mkSlot('$result'), src: mkSlot('$src') },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(2);
+    });
+    test('merges multiple adjacent call_context + score_set pairs', () => {
+        const ctx1 = {
+            kind: 'call_context',
+            fn: 'ns:fn1',
+            subcommands: [{ kind: 'as', selector: '@s' }],
+        };
+        const ctx2 = {
+            kind: 'call_context',
+            fn: 'ns:fn2',
+            subcommands: [{ kind: 'at_self' }],
+        };
+        const fn = mkFn([
+            ctx1,
+            { kind: 'score_set', dst: mkSlot('$r1'), value: 1 },
+            ctx2,
+            { kind: 'score_set', dst: mkSlot('$r2'), value: 1 },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result.instructions[0]).toEqual({
+            kind: 'store_cmd_to_score',
+            dst: mkSlot('$r1'),
+            cmd: ctx1,
+        });
+        expect(result.instructions[1]).toEqual({
+            kind: 'store_cmd_to_score',
+            dst: mkSlot('$r2'),
+            cmd: ctx2,
+        });
+    });
+    test('returns same reference when nothing changed', () => {
+        const fn = mkFn([
+            { kind: 'call', fn: 'ns:myfn' },
+            { kind: 'score_copy', dst: mkSlot('$a'), src: mkSlot('$b') },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result).toBe(fn);
+    });
+    test('handles empty instruction list', () => {
+        const fn = mkFn([]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result).toBe(fn);
+    });
+    test('handles single instruction', () => {
+        const fn = mkFn([{ kind: 'score_set', dst: mkSlot('$x'), value: 5 }]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result).toBe(fn);
+    });
+});
+//# sourceMappingURL=peephole.test.js.map

package/dist/src/__tests__/optimizer/lir/pipeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer/lir/pipeline.test.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_1 = require("../../../optimizer/lir/pipeline");
+const obj = '__test';
+function mkSlot(player) {
+    return { player, obj };
+}
+function mkFn(name, instructions) {
+    return { name, instructions, isMacro: false, macroParams: [] };
+}
+function mkModule(functions) {
+    return { functions, namespace: 'test', objective: obj };
+}
+describe('LIR optimization pipeline', () => {
+    test('dead slot + const_imm combined: removes dead write and folds constant', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                // Dead write — $dead is never read anywhere
+                { kind: 'score_set', dst: mkSlot('$dead'), value: 99 },
+                // Constant add pattern
+                { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+                { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+                { kind: 'return_value', slot: mkSlot('$x') },
+            ]),
+        ]);
+        const result = (0, pipeline_1.lirOptimizeModule)(mod);
+        const instrs = result.functions[0].instructions;
+        // $dead should be removed by dead_slot
+        expect(instrs.some(i => i.kind === 'score_set' && i.dst.player === '$dead')).toBe(false);
+        // const+add should be folded by const_imm
+        expect(instrs.some(i => i.kind === 'raw' && i.cmd.includes('scoreboard players add $x'))).toBe(true);
+    });
+    test('dead slot enables const_imm: removing extra use makes const single-use', () => {
+        // $__const_5 is used twice: once in score_add and once in a dead score_copy
+        // After dead_slot removes the dead copy, $__const_5 becomes single-use → foldable
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+                { kind: 'score_copy', dst: mkSlot('$dead'), src: mkSlot('$__const_5') },
+                { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+                { kind: 'return_value', slot: mkSlot('$x') },
+            ]),
+        ]);
+        const result = (0, pipeline_1.lirOptimizeModule)(mod);
+        const instrs = result.functions[0].instructions;
+        // The dead copy should be gone and const_imm should fold
+        expect(instrs.some(i => i.kind === 'raw' && i.cmd.includes('scoreboard players add $x'))).toBe(true);
+        expect(instrs.some(i => i.kind === 'score_copy' && i.dst.player === '$dead')).toBe(false);
+    });
+    test('preserves module when no optimizations apply', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: mkSlot('$x'), value: 1 },
+                { kind: 'return_value', slot: mkSlot('$x') },
+            ]),
+        ]);
+        const result = (0, pipeline_1.lirOptimizeModule)(mod);
+        expect(result.functions[0].instructions).toHaveLength(2);
+    });
+    test('works across multiple functions', () => {
+        const mod = mkModule([
+            mkFn('fn1', [
+                { kind: 'score_set', dst: mkSlot('$dead_in_fn1'), value: 0 },
+                { kind: 'score_set', dst: mkSlot('$__const_10'), value: 10 },
+                { kind: 'score_add', dst: mkSlot('$a'), src: mkSlot('$__const_10') },
+                { kind: 'return_value', slot: mkSlot('$a') },
+            ]),
+            mkFn('fn2', [
+                { kind: 'score_set', dst: mkSlot('$__const_3'), value: 3 },
+                { kind: 'score_sub', dst: mkSlot('$b'), src: mkSlot('$__const_3') },
+                { kind: 'return_value', slot: mkSlot('$b') },
+            ]),
+        ]);
+        const result = (0, pipeline_1.lirOptimizeModule)(mod);
+        // fn1: dead write removed, const folded
+        const fn1 = result.functions[0];
+        expect(fn1.instructions.some(i => i.kind === 'score_set' && i.dst.player === '$dead_in_fn1')).toBe(false);
+        expect(fn1.instructions.some(i => i.kind === 'raw' && i.cmd.includes('add $a'))).toBe(true);
+        // fn2: const folded
+        const fn2 = result.functions[1];
+        expect(fn2.instructions.some(i => i.kind === 'raw' && i.cmd.includes('remove $b'))).toBe(true);
+    });
+});
+//# sourceMappingURL=pipeline.test.js.map

package/dist/src/__tests__/optimizer/nbt-batch.test.d.ts

@@ -0,0 +1 @@
+export {};