redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/optimizer/optimizer-extended.test.js

@@ -0,0 +1,993 @@
+"use strict";
+/**
+ * Extended optimizer coverage tests.
+ *
+ * Targets uncovered branches in:
+ * - coroutine.ts  (fnContainsMacroCalls paths, macro-skip warning)
+ * - unroll.ts     (two-step latch pattern, initializesTo0 copy path, copy-init path)
+ * - interprocedural.ts  (call_macro isSelfRecursive, param mismatch guard, rewriteCallSites guards)
+ * - lir/const_imm.ts  (score_swap / store_nbt_to_score / macro_line read slots, extractSlotsFromRaw)
+ * - block_merge.ts  (branch terminator — no merge, target === fn.entry guard)
+ * - constant_fold.ts  (evalCmp default branch)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// ---------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------
+const coroutine_1 = require("../../optimizer/coroutine");
+const unroll_1 = require("../../optimizer/unroll");
+const interprocedural_1 = require("../../optimizer/interprocedural");
+const const_imm_1 = require("../../optimizer/lir/const_imm");
+const block_merge_1 = require("../../optimizer/block_merge");
+const constant_fold_1 = require("../../optimizer/constant_fold");
+// ---------------------------------------------------------------------------
+// MIR helpers
+// ---------------------------------------------------------------------------
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+function mirBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+function mirFn(name, params, blocks, isMacro = false) {
+    return {
+        name,
+        params: params.map(p => ({ name: p, isMacroParam: false })),
+        blocks,
+        entry: 'entry',
+        isMacro,
+    };
+}
+function mirMod(functions) {
+    return { functions, namespace: 'test', objective: '__test' };
+}
+// ---------------------------------------------------------------------------
+// LIR helpers
+// ---------------------------------------------------------------------------
+const obj = '__test';
+function slot(player) { return { player, obj }; }
+function lirFn(instructions) {
+    return { name: 'test', instructions, isMacro: false, macroParams: [] };
+}
+// ===========================================================================
+// 1. coroutine.ts — uncovered branches
+// ===========================================================================
+describe('coroutine — fnContainsMacroCalls skip path', () => {
+    function mkBlock(id, instrs, term) {
+        return { id, instrs, term, preds: [] };
+    }
+    test('skips transform and emits warning when function has call_macro', () => {
+        const fn = {
+            name: 'test:worker',
+            params: [],
+            blocks: [
+                mkBlock('entry', [
+                    // call_macro instruction — should trigger the skip path
+                    { kind: 'call_macro', dst: null, fn: 'test:mfn', args: [] },
+                ], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const mod = mirMod([fn]);
+        const info = { fnName: 'test:worker', batch: 10 };
+        const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+        // Function should be kept unchanged (not transformed)
+        expect(result.module.functions).toHaveLength(1);
+        expect(result.module.functions[0].name).toBe('test:worker');
+        // No tick functions generated
+        expect(result.generatedTickFunctions).toHaveLength(0);
+        // Warning should be emitted
+        expect(result.warnings).toHaveLength(1);
+        expect(result.warnings[0]).toContain('test:worker');
+        expect(result.warnings[0]).toContain('@coroutine');
+    });
+    test('skips transform when function has __raw: call with ${interpolation}', () => {
+        const fn = {
+            name: 'test:interpolated',
+            params: [],
+            blocks: [
+                mkBlock('entry', [
+                    // A raw call with variable interpolation
+                    { kind: 'call', dst: null, fn: '__raw:say ${name}', args: [] },
+                ], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const mod = mirMod([fn]);
+        const info = { fnName: 'test:interpolated', batch: 10 };
+        const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+        expect(result.module.functions).toHaveLength(1);
+        expect(result.generatedTickFunctions).toHaveLength(0);
+        expect(result.warnings).toHaveLength(1);
+    });
+    test('skips transform when function has __raw:\\x01 (builtin with macro)', () => {
+        const fn = {
+            name: 'test:builtin_macro',
+            params: [],
+            blocks: [
+                mkBlock('entry', [
+                    { kind: 'call', dst: null, fn: '__raw:\x01particle dust', args: [] },
+                ], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const mod = mirMod([fn]);
+        const info = { fnName: 'test:builtin_macro', batch: 5 };
+        const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+        expect(result.generatedTickFunctions).toHaveLength(0);
+        expect(result.warnings).toHaveLength(1);
+    });
+    test('transforms when __raw: call has no interpolation', () => {
+        // __raw: without ${ or \x01 should NOT block the transform
+        const fn = {
+            name: 'test:plain_raw',
+            params: [],
+            blocks: [
+                mkBlock('entry', [
+                    { kind: 'call', dst: null, fn: '__raw:say hello', args: [] },
+                ], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const mod = mirMod([fn]);
+        const info = { fnName: 'test:plain_raw', batch: 5 };
+        const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+        // Should be transformed (no warning)
+        expect(result.warnings).toHaveLength(0);
+        expect(result.generatedTickFunctions).toHaveLength(1);
+    });
+    test('call_macro in terminator position also triggers skip', () => {
+        // The loop in fnContainsMacroCalls iterates [...block.instrs, block.term]
+        // so a call_macro as the terminator should also trigger the skip
+        const fn = {
+            name: 'test:macro_term',
+            params: [],
+            blocks: [
+                {
+                    id: 'entry',
+                    instrs: [],
+                    // call_macro as terminator
+                    term: { kind: 'call_macro', dst: null, fn: 'test:m', args: [] },
+                    preds: [],
+                },
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const mod = mirMod([fn]);
+        const info = { fnName: 'test:macro_term', batch: 5 };
+        const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+        expect(result.warnings).toHaveLength(1);
+        expect(result.generatedTickFunctions).toHaveLength(0);
+    });
+});
+// ===========================================================================
+// 2. unroll.ts — uncovered branches
+// ===========================================================================
+describe('loopUnroll — uncovered branches', () => {
+    function buildLoopWithBlocks(blocks) {
+        return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+    }
+    test('two-step latch pattern: add t_tmp i 1; copy i t_tmp', () => {
+        // Pattern 2 in latchIncrementsBy1
+        const fn = buildLoopWithBlocks([
+            mirBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mirBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mirBlock('loop_latch_0', [
+                // Two-step increment: t_tmp = i + 1; i = t_tmp
+                { kind: 'add', dst: 't_tmp', a: t('i'), b: c(1) },
+                { kind: 'copy', dst: 'i', src: t('t_tmp') },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Should have unrolled — loop_header gone
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(i => i.kind === 'call');
+        expect(calls).toHaveLength(3);
+        // i substituted as 0, 1, 2
+        const callInstrs = calls;
+        expect(callInstrs[0].args[0]).toEqual(c(0));
+        expect(callInstrs[1].args[0]).toEqual(c(1));
+        expect(callInstrs[2].args[0]).toEqual(c(2));
+    });
+    test('initializesTo0 via copy instruction (copy i, const 0)', () => {
+        // Tests the `copy` branch in initializesTo0
+        const fn = buildLoopWithBlocks([
+            mirBlock('entry', [
+                // Initialize via copy of const 0 instead of direct const
+                { kind: 'copy', dst: 'i', src: c(0) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(2) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mirBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mirBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Should unroll since copy i, 0 is recognized as init-to-0
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(i => i.kind === 'call');
+        expect(calls).toHaveLength(2);
+    });
+    test('initializesTo0 copy with non-zero const does not unroll', () => {
+        // copy i, const 5 — not init to 0
+        const fn = buildLoopWithBlocks([
+            mirBlock('entry', [
+                { kind: 'copy', dst: 'i', src: c(5) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(8) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mirBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mirBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn); // unchanged
+    });
+    test('latch with wrong temp in two-step does not unroll', () => {
+        // Pattern 2 but copy is from a different temp than the add destination
+        const fn = buildLoopWithBlocks([
+            mirBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mirBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mirBlock('loop_latch_0', [
+                // Two-step but the copy sources from a different unrelated temp
+                { kind: 'add', dst: 't_tmp', a: t('i'), b: c(1) },
+                { kind: 'copy', dst: 'i', src: t('other_tmp') }, // wrong source
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Should NOT unroll — two-step mismatch
+        expect(result).toBe(fn);
+    });
+    test('multiple loops in function: unrolls both iteratively', () => {
+        // Two sequential loops, both N=2 — fixpoint iteration handles both
+        const fn = buildLoopWithBlocks([
+            mirBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: t('i'), b: c(2) },
+            ], { kind: 'branch', cond: t('t0'), then: 'loop_body_0', else: 'mid' }),
+            mirBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:a', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mirBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mirBlock('mid', [
+                { kind: 'const', dst: 'j', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_1' }),
+            mirBlock('loop_header_1', [
+                { kind: 'cmp', dst: 't1', op: 'lt', a: t('j'), b: c(2) },
+            ], { kind: 'branch', cond: t('t1'), then: 'loop_body_1', else: 'loop_exit_1' }),
+            mirBlock('loop_body_1', [
+                { kind: 'call', dst: null, fn: 'test:b', args: [t('j')] },
+            ], { kind: 'jump', target: 'loop_latch_1' }),
+            mirBlock('loop_latch_1', [
+                { kind: 'add', dst: 'j', a: t('j'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_1' }),
+            mirBlock('loop_exit_1', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Both loops should be unrolled
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+    });
+});
+// ===========================================================================
+// 3. interprocedural.ts — uncovered branches
+// ===========================================================================
+describe('interproceduralConstProp — uncovered branches', () => {
+    test('isSelfRecursive: function calling itself via call_macro is not specialized', () => {
+        // A function that is self-recursive via call_macro should be skipped
+        const selfRecursiveFn = mirFn('test:recur', ['n'], [
+            mirBlock('entry', [
+                // call_macro to itself
+                { kind: 'call_macro', dst: null, fn: 'test:recur', args: [] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const callerFn = mirFn('test:main', [], [
+            mirBlock('entry', [
+                { kind: 'call', dst: null, fn: 'test:recur', args: [c(5)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mirMod([callerFn, selfRecursiveFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        // Should NOT create specialized version — self-recursive via call_macro
+        expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false);
+    });
+    test('param count mismatch: callee.params.length !== instr.args.length skips', () => {
+        // Callee expects 2 params but call site provides 1 — should not specialize
+        const addFn = mirFn('test:add', ['a', 'b'], [
+            mirBlock('entry', [
+                { kind: 'add', dst: 'r', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const callerFn = mirFn('test:main', [], [
+            mirBlock('entry', [
+                // Only 1 arg but callee expects 2
+                { kind: 'call', dst: null, fn: 'test:add', args: [c(3)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mirMod([callerFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false);
+    });
+    test('rewriteCallSites skips call_macro instructions (not rewritten)', () => {
+        // rewriteCallSites only rewrites 'call' not 'call_macro'
+        const helperFn = mirFn('test:helper', ['x'], [
+            mirBlock('entry', [], { kind: 'return', value: null }),
+        ]);
+        const callerFn = mirFn('test:main', [], [
+            mirBlock('entry', [
+                // call_macro — should not be rewritten even if specialized fn exists
+                { kind: 'call_macro', dst: null, fn: 'test:helper', args: [] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mirMod([callerFn, helperFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const macroCall = main.blocks[0].instrs.find(i => i.kind === 'call_macro');
+        // Should remain unchanged
+        expect(macroCall).toBeDefined();
+    });
+    test('rewriteCallSites: call with self-same name is not rewritten', () => {
+        // When callee.name === fn.name (self-call) in rewriteCallSites, skip
+        const selfCallFn = mirFn('test:fib', ['n'], [
+            mirBlock('entry', [
+                // direct self-call with constant arg — rewriteCallSites should skip
+                { kind: 'call', dst: null, fn: 'test:fib', args: [c(5)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mirMod([selfCallFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        const fib = result.functions.find(f => f.name === 'test:fib');
+        const call = fib.blocks[0].instrs.find(i => i.kind === 'call');
+        // Self call should remain unchanged
+        expect(call.fn).toBe('test:fib');
+    });
+    test('rewriteCallSites: call with non-all-const args is not rewritten', () => {
+        const addFn = mirFn('test:add', ['a', 'b'], [
+            mirBlock('entry', [
+                { kind: 'add', dst: 'r', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const callerFn = mirFn('test:main', [], [
+            mirBlock('entry', [
+                // Mixed args — not all const
+                { kind: 'call', dst: null, fn: 'test:add', args: [t('x'), c(4)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mirMod([callerFn, addFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const call = main.blocks[0].instrs.find(i => i.kind === 'call');
+        // Should remain as 'test:add' (not rewritten)
+        expect(call.fn).toBe('test:add');
+    });
+    test('callee with multiple blocks is not specialized', () => {
+        // Only single-block callees are specialized
+        const multiFn = mirFn('test:multi', ['x'], [
+            mirBlock('entry', [
+                { kind: 'cmp', dst: 'cond', op: 'gt', a: t('x'), b: c(0) },
+            ], { kind: 'branch', cond: t('cond'), then: 'pos', else: 'neg' }),
+            mirBlock('pos', [], { kind: 'return', value: c(1) }),
+            mirBlock('neg', [], { kind: 'return', value: c(0) }),
+        ]);
+        const callerFn = mirFn('test:main', [], [
+            mirBlock('entry', [
+                { kind: 'call', dst: null, fn: 'test:multi', args: [c(5)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mirMod([callerFn, multiFn]);
+        const result = (0, interprocedural_1.interproceduralConstProp)(mod);
+        expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false);
+    });
+});
+// ===========================================================================
+// 4. lir/const_imm.ts — uncovered branches
+// ===========================================================================
+describe('constImmFold — getReadSlots uncovered branches', () => {
+    test('score_swap: both slots a and b are read slots', () => {
+        // score_swap uses both a and b — getReadSlots returns [a, b]
+        // If one of them is the $__const_ slot, use count is > 1 → no fold
+        const constSlot = slot('$__const_5');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 5 },
+            { kind: 'score_swap', a: constSlot, b: slot('$x') },
+            { kind: 'score_add', dst: slot('$y'), src: constSlot },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        // $__const_5 is used twice (swap + add) → no fold
+        expect(result.instructions).toHaveLength(3);
+        expect(result).toBe(fn);
+    });
+    test('store_nbt_to_score: does not count as reading a slot', () => {
+        // store_nbt_to_score reads from NBT, not a score slot — getReadSlots returns []
+        // So $__const_5 with only score_add as user → folds
+        const constSlot = slot('$__const_5');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 5 },
+            // store_nbt_to_score does NOT read constSlot
+            { kind: 'store_nbt_to_score', dst: slot('$z'), ns: 'test', path: 'data', scale: 1 },
+            { kind: 'score_add', dst: slot('$x'), src: constSlot },
+        ]);
+        // Not adjacent (store_nbt_to_score is between) — no fold
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('macro_line: slots referenced in template are counted', () => {
+        // macro_line uses extractSlotsFromRaw on the template field
+        const constSlot = slot('$__const_5');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 5 },
+            // macro_line that references constSlot in template
+            { kind: 'macro_line', template: `$__const_5 ${obj}` },
+            { kind: 'score_add', dst: slot('$x'), src: constSlot },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        // $__const_5 is used in macro_line template + score_add → 2 uses → no fold
+        expect(result).toBe(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('extractSlotsFromRaw: raw cmd with player-obj pattern extracts slot', () => {
+        // raw instruction — slots extracted via regex /(\$[\w.:]+)\s+(\S+)/g
+        const constSlot = slot('$__const_7');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 7 },
+            // raw command that references constSlot
+            { kind: 'raw', cmd: `scoreboard players get $__const_7 ${obj}` },
+            { kind: 'score_add', dst: slot('$a'), src: constSlot },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        // constSlot used in raw + score_add → 2 uses → no fold
+        expect(result).toBe(fn);
+    });
+    test('raw cmd with no matching slots: slot is not counted', () => {
+        // A raw cmd with no $-prefixed player references
+        const constSlot = slot('$__const_3');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 3 },
+            { kind: 'raw', cmd: 'say hello world' }, // no slot references
+            { kind: 'score_add', dst: slot('$x'), src: constSlot },
+        ]);
+        // constSlot used only once (score_add), but not adjacent to score_set
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result.instructions).toHaveLength(3); // not adjacent → no fold
+    });
+    test('call_if_score: both a and b slots are counted as reads', () => {
+        // call_if_score reads both a and b — if constSlot appears as either, use count++
+        const constSlot = slot('$__const_4');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 4 },
+            { kind: 'call_if_score', fn: 'test:f', a: constSlot, op: 'gt', b: slot('$x') },
+            { kind: 'score_add', dst: slot('$y'), src: constSlot },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        // constSlot used in call_if_score (a) + score_add → 2 uses → no fold
+        expect(result).toBe(fn);
+    });
+    test('return_value: slot is counted as a read', () => {
+        // return_value reads the slot — if constSlot is returned, use count++
+        const constSlot = slot('$__const_9');
+        const fn = lirFn([
+            { kind: 'score_set', dst: constSlot, value: 9 },
+            { kind: 'score_add', dst: slot('$x'), src: constSlot },
+            { kind: 'return_value', slot: constSlot },
+        ]);
+        // Two uses of constSlot (score_add + return_value) — no fold for the score_add pair
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result).toBe(fn);
+    });
+    test('instructions length < 2: returns fn unchanged', () => {
+        const fn = lirFn([
+            { kind: 'score_set', dst: slot('$x'), value: 1 },
+        ]);
+        const result = (0, const_imm_1.constImmFold)(fn);
+        expect(result).toBe(fn);
+    });
+});
+// ===========================================================================
+// 5. block_merge.ts — uncovered branch
+// ===========================================================================
+describe('blockMerge — uncovered branches', () => {
+    test('branch terminator: block with branch does not trigger merge', () => {
+        // The merge condition requires term.kind === 'jump'; a branch should not merge
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [], {
+                    kind: 'branch', cond: t('c'), then: 'b1', else: 'b2',
+                }),
+                mirBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+                mirBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const result = (0, block_merge_1.blockMerge)(fn);
+        // Should have all 3 blocks — no merge possible
+        expect(result.blocks).toHaveLength(3);
+    });
+    test('jump to entry block: not merged (entry guard)', () => {
+        // A block jumping to 'entry' should not cause entry to be merged away
+        // (the `targetId !== fn.entry` guard)
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'x', value: 1 },
+                ], { kind: 'return', value: t('x') }),
+                // A block that jumps to entry (unusual but valid for testing)
+                mirBlock('before', [], { kind: 'jump', target: 'entry' }),
+            ],
+            entry: 'before',
+            isMacro: false,
+        };
+        const result = (0, block_merge_1.blockMerge)(fn);
+        // 'entry' has 1 pred (before) but is the fn.entry — guard prevents merge?
+        // Actually fn.entry = 'before', so 'entry' is NOT fn.entry here — it should merge
+        // Let's verify: before → entry (single pred), entry is not fn.entry ('before' is)
+        // So entry gets merged into before
+        expect(result.blocks.some(b => b.id === 'before')).toBe(true);
+    });
+    test('target not in blockMap: merge is skipped gracefully', () => {
+        // If target block doesn't exist in blockMap, blockMap.get returns undefined
+        // The `if (target && ...)` guard handles this
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [], { kind: 'jump', target: 'nonexistent' }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        // Should not throw — target not found means no merge
+        const result = (0, block_merge_1.blockMerge)(fn);
+        expect(result.blocks).toHaveLength(1);
+    });
+    test('already-removed block is skipped in iteration', () => {
+        // When A merges B, B is added to `removed`. If blocks array processes B again, it skips.
+        // A → B → C (all single-pred). B merges into A in first iteration;
+        // then A+B → C merges in second iteration.
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [{ kind: 'const', dst: 'a', value: 1 }], { kind: 'jump', target: 'b1' }),
+                mirBlock('b1', [{ kind: 'const', dst: 'b', value: 2 }], { kind: 'jump', target: 'b2' }, ['entry']),
+                mirBlock('b2', [{ kind: 'const', dst: 'c', value: 3 }], { kind: 'return', value: null }, ['b1']),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const result = (0, block_merge_1.blockMerge)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].instrs).toHaveLength(3);
+    });
+});
+// ===========================================================================
+// 2b. unroll.ts — additional uncovered branches
+// ===========================================================================
+describe('loopUnroll — additional edge cases', () => {
+    test('initializesTo0: another instr defines loopVar before const → returns false', () => {
+        // In initializesTo0, if getInstrDst returns loopVar for a non-const, non-copy instr → false
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    // Another instr defines 'i' — then const i 0 never reached in reverse scan
+                    { kind: 'add', dst: 'i', a: c(1), b: c(1) }, // defines i = 2
+                    { kind: 'const', dst: 'i', value: 0 }, // defines i = 0 (last def wins in reverse)
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        // Reverse scan hits const i 0 first → should unroll
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+    });
+    test('initializesTo0: loopVar defined by non-zero non-copy instr → false', () => {
+        // In reverse scan: first hit is add dst=i → getInstrDst returns 'i' → return false
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    // Only a non-zero add defines i — no const 0 before it in reverse scan
+                    { kind: 'add', dst: 'i', a: c(5), b: c(3) }, // defines i (not 0)
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn); // not unrolled — not initialized to 0
+    });
+    test('findPreHeader: multiple predecessors to header → no unroll', () => {
+        // If loop_header has more than one non-latch predecessor, findPreHeader returns null
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'branch', cond: t('some_cond'), then: 'loop_header_0', else: 'alt' }),
+                mirBlock('alt', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                // loop_header has two non-latch preds: entry and alt
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn); // not unrolled — ambiguous pre-header
+    });
+    test('body with nbt_write_dynamic substitutes both indexSrc and valueSrc', () => {
+        // Covers the nbt_write_dynamic case in substituteInstr
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(2) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    // nbt_write_dynamic with i as both indexSrc and valueSrc
+                    {
+                        kind: 'nbt_write_dynamic',
+                        ns: 'test', pathPrefix: 'arr',
+                        indexSrc: t('i'),
+                        valueSrc: t('i'),
+                    },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Should unroll — 2 copies
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const writes = entry.instrs.filter(i => i.kind === 'nbt_write_dynamic');
+        expect(writes).toHaveLength(2);
+        // Both indexSrc and valueSrc should be substituted
+        const w0 = writes[0];
+        expect(w0.indexSrc).toEqual(c(0));
+        expect(w0.valueSrc).toEqual(c(0));
+    });
+    test('body with nbt_write substitutes src', () => {
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(2) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'nbt_write', ns: 'test', path: 'val', type: 'int', scale: 1, src: t('i') },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const writes = entry.instrs.filter(i => i.kind === 'nbt_write');
+        expect(writes).toHaveLength(2);
+        expect(writes[0].src).toEqual(c(0));
+        expect(writes[1].src).toEqual(c(1));
+    });
+    test('body with call_macro substitutes arg values', () => {
+        // Covers the call_macro case in substituteInstr
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(2) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    {
+                        kind: 'call_macro',
+                        dst: null,
+                        fn: 'test:macro_fn',
+                        args: [{ name: 'x', value: t('i'), type: 'int', scale: 1 }],
+                    },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const macroCalls = entry.instrs.filter(i => i.kind === 'call_macro');
+        expect(macroCalls).toHaveLength(2);
+        expect(macroCalls[0].args[0].value).toEqual(c(0));
+        expect(macroCalls[1].args[0].value).toEqual(c(1));
+    });
+    test('body with return instr: substitutes value', () => {
+        // return with value — substituteInstr covers the return case
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(2) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                // Body ending with a terminator substitution test via branch (cond=i)
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:f', args: [] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: t('i') }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Unrolled — exit is kept with return value
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+    });
+    test('loop with N=0: does not unroll (N <= 0 guard)', () => {
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(0) },
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:body', args: [] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn); // N=0 is rejected
+    });
+    test('loop_header with no cmp instr: not unrolled', () => {
+        // header has branch but no cmp instruction for condName
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                // No cmp here — branch uses t_cmp but nothing defines it
+                ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:body', args: [] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn);
+    });
+    test('loop_header with const cond (not temp): not unrolled', () => {
+        // branch.cond must be temp — if it's const, skip
+        const fn = {
+            name: 'test', params: [], entry: 'entry', isMacro: false,
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'const', dst: 'i', value: 0 },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_header_0', [
+                    { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+                ], { kind: 'branch', cond: c(1), then: 'loop_body_0', else: 'loop_exit_0' }),
+                mirBlock('loop_body_0', [
+                    { kind: 'call', dst: null, fn: 'test:body', args: [] },
+                ], { kind: 'jump', target: 'loop_latch_0' }),
+                mirBlock('loop_latch_0', [
+                    { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+                ], { kind: 'jump', target: 'loop_header_0' }),
+                mirBlock('loop_exit_0', [], { kind: 'return', value: null }),
+            ],
+        };
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn);
+    });
+});
+// ===========================================================================
+// 6. constant_fold.ts — uncovered branch (evalCmp default)
+// ===========================================================================
+describe('constantFold — evalCmp default branch', () => {
+    test('unknown cmp op falls through to default (returns 0)', () => {
+        // The default case in evalCmp — an op that doesn't match any known op
+        // We test through constantFold by constructing a cmp with unknown op
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [
+                    // Use an unknown cmp op — TypeScript won't normally allow this
+                    // but we cast to test the runtime default branch
+                    {
+                        kind: 'cmp',
+                        dst: 'result',
+                        op: 'unknown_op',
+                        a: c(5),
+                        b: c(3),
+                    },
+                ], { kind: 'return', value: t('result') }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const result = (0, constant_fold_1.constantFold)(fn);
+        // Should have folded cmp(unknown_op, 5, 3) → const 0 (default case)
+        const instr = result.blocks[0].instrs[0];
+        expect(instr.kind).toBe('const');
+        if (instr.kind === 'const') {
+            expect(instr.value).toBe(0);
+            expect(instr.dst).toBe('result');
+        }
+    });
+    test('all six cmp ops fold correctly', () => {
+        // Regression: verify all known ops work (these are covered but good to have)
+        const ops = [
+            { op: 'eq', a: 5, b: 5, expected: 1 },
+            { op: 'eq', a: 5, b: 3, expected: 0 },
+            { op: 'ne', a: 5, b: 3, expected: 1 },
+            { op: 'ne', a: 5, b: 5, expected: 0 },
+            { op: 'lt', a: 3, b: 5, expected: 1 },
+            { op: 'lt', a: 5, b: 3, expected: 0 },
+            { op: 'le', a: 5, b: 5, expected: 1 },
+            { op: 'le', a: 6, b: 5, expected: 0 },
+            { op: 'gt', a: 5, b: 3, expected: 1 },
+            { op: 'gt', a: 3, b: 5, expected: 0 },
+            { op: 'ge', a: 5, b: 5, expected: 1 },
+            { op: 'ge', a: 4, b: 5, expected: 0 },
+        ];
+        for (const { op, a: av, b: bv, expected } of ops) {
+            const fn = {
+                name: 'test',
+                params: [],
+                blocks: [
+                    mirBlock('entry', [
+                        { kind: 'cmp', dst: 'r', op, a: c(av), b: c(bv) },
+                    ], { kind: 'return', value: t('r') }),
+                ],
+                entry: 'entry',
+                isMacro: false,
+            };
+            const result = (0, constant_fold_1.constantFold)(fn);
+            const instr = result.blocks[0].instrs[0];
+            expect(instr.kind).toBe('const');
+            if (instr.kind === 'const') {
+                expect(instr.value).toBe(expected);
+            }
+        }
+    });
+    test('cmp with non-const operands is not folded', () => {
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'cmp', dst: 'r', op: 'lt', a: t('x'), b: c(5) },
+                ], { kind: 'return', value: t('r') }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const result = (0, constant_fold_1.constantFold)(fn);
+        // Not folded — a is temp
+        expect(result.blocks[0].instrs[0].kind).toBe('cmp');
+    });
+    test('div by zero is not folded', () => {
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'div', dst: 'r', a: c(10), b: c(0) },
+                ], { kind: 'return', value: t('r') }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const result = (0, constant_fold_1.constantFold)(fn);
+        // div by 0 should not be folded
+        expect(result.blocks[0].instrs[0].kind).toBe('div');
+    });
+    test('mod by zero is not folded', () => {
+        const fn = {
+            name: 'test',
+            params: [],
+            blocks: [
+                mirBlock('entry', [
+                    { kind: 'mod', dst: 'r', a: c(10), b: c(0) },
+                ], { kind: 'return', value: t('r') }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('mod');
+    });
+});
+//# sourceMappingURL=optimizer-extended.test.js.map