redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/optimizer/nbt-batch.test.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nbt_batch_1 = require("../../optimizer/nbt-batch");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const t = (n) => ({ kind: 'temp', name: n });
+describe('nbtBatchRead', () => {
+    test('deduplicates identical nbt_read in same block', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('nbt_read');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+    });
+    test('does not deduplicate reads with different path', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'FoodLevel', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('nbt_read');
+        expect(instrs[1].kind).toBe('nbt_read');
+    });
+    test('does not deduplicate reads with different ns', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_read', dst: 't1', ns: '@p', path: 'Health', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('nbt_read');
+        expect(instrs[1].kind).toBe('nbt_read');
+    });
+    test('invalidates cache after nbt_write to same ns', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_write', ns: '@s', path: 'Health', type: 'int', scale: 1, src: { kind: 'const', value: 20 } },
+                { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('nbt_read');
+        expect(instrs[1].kind).toBe('nbt_write');
+        expect(instrs[2].kind).toBe('nbt_read');
+    });
+    test('deduplicates third read that has no intervening write', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_read', dst: 't2', ns: '@s', path: 'Health', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('nbt_read');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+        expect(instrs[2]).toEqual({ kind: 'copy', dst: 't2', src: { kind: 'temp', name: 't0' } });
+    });
+    test('does not deduplicate across blocks', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+            ], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [
+                { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('nbt_read');
+        expect(result.blocks[1].instrs[0].kind).toBe('nbt_read');
+    });
+    test('does not deduplicate reads with different scale', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+                { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 2 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('nbt_read');
+        expect(result.blocks[0].instrs[1].kind).toBe('nbt_read');
+    });
+    test('no change when no duplicates', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, nbt_batch_1.nbtBatchRead)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('nbt_read');
+    });
+});
+//# sourceMappingURL=nbt-batch.test.js.map

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_1 = require("../../optimizer/pipeline");
+function mkFn(blocks, entry = 'entry') {
+    return { name: 'test', params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('optimization pipeline', () => {
+    test('constant fold + branch simplify + DCE removes dead branch', () => {
+        // cmp(lt, 1, 2) → 1 → branch(1, then, else) → jump(then) → else is dead
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: c(1), b: c(2) },
+            ], { kind: 'branch', cond: t('t0'), then: 'then', else: 'else' }),
+            mkBlock('then', [], { kind: 'return', value: c(1) }, ['entry']),
+            mkBlock('else', [], { kind: 'return', value: c(0) }, ['entry']),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // After optimization: entry should return 1 directly, else block removed
+        // The cmp folds to const 1, branch simplifies to jump(then),
+        // else block becomes unreachable and is removed,
+        // then block merges into entry
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(1) });
+    });
+    test('copy prop + const fold + DCE eliminates dead copy and folds', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'a', value: 5 },
+                { kind: 'copy', dst: 'b', src: t('a') },
+                { kind: 'add', dst: 'c', a: t('b'), b: c(1) },
+            ], { kind: 'return', value: t('c') }),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // const a=5 propagated into copy and add, add(5,1) folded to 6
+        // all dead defs removed, returns const 6
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(6) });
+    });
+    test('full pipeline: fold + simplify + merge + dce', () => {
+        // if (3 > 2) { return 10 + 20; } else { return 0; }
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'gt', a: c(3), b: c(2) },
+            ], { kind: 'branch', cond: t('t0'), then: 'then', else: 'else' }),
+            mkBlock('then', [
+                { kind: 'add', dst: 't1', a: c(10), b: c(20) },
+            ], { kind: 'return', value: t('t1') }, ['entry']),
+            mkBlock('else', [], { kind: 'return', value: c(0) }, ['entry']),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // Everything folds away: single block returning const 30
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(30) });
+    });
+    test('optimizeModule applies to all functions', () => {
+        const mod = {
+            namespace: 'test',
+            objective: '__test',
+            functions: [
+                mkFn([
+                    mkBlock('entry', [
+                        { kind: 'add', dst: 't0', a: c(1), b: c(2) },
+                    ], { kind: 'return', value: t('t0') }),
+                ]),
+                mkFn([
+                    mkBlock('entry', [
+                        { kind: 'mul', dst: 't0', a: c(3), b: c(4) },
+                    ], { kind: 'return', value: t('t0') }),
+                ]),
+            ],
+        };
+        const result = (0, pipeline_1.optimizeModule)(mod);
+        // Both functions should have their constants folded
+        for (const fn of result.functions) {
+            const instrs = fn.blocks[0].instrs;
+            const hasArith = instrs.some(i => i.kind === 'add' || i.kind === 'mul');
+            expect(hasArith).toBe(false);
+        }
+    });
+    test('fixpoint: multiple iterations needed', () => {
+        // First iteration: fold add → const, fold cmp → const
+        // Second iteration: branch simplify on newly-const cond
+        // Third iteration: DCE removes dead block, merge
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(1), b: c(1) },
+                { kind: 'cmp', dst: 't1', op: 'eq', a: t('t0'), b: c(2) },
+            ], { kind: 'branch', cond: t('t1'), then: 'yes', else: 'no' }),
+            mkBlock('yes', [], { kind: 'return', value: c(1) }, ['entry']),
+            mkBlock('no', [], { kind: 'return', value: c(0) }, ['entry']),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // 1+1=2, 2==2 → 1, branch(1) → jump(yes), dead block removed, merged
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(1) });
+    });
+});
+//# sourceMappingURL=pipeline.test.js.map

package/dist/src/__tests__/optimizer/selector-cache.test.d.ts

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

package/dist/src/__tests__/optimizer/selector-cache.test.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const selector_cache_1 = require("../../optimizer/selector-cache");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+describe('selectorCache', () => {
+    test('replaces 2nd occurrence of repeated complex selector with tag', () => {
+        const sel = '@e[type=zombie,distance=..10]';
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call_context', fn: 'ns:attack', subcommands: [{ kind: 'as', selector: sel }] },
+                { kind: 'call_context', fn: 'ns:move', subcommands: [{ kind: 'as', selector: sel }] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, selector_cache_1.selectorCache)(fn);
+        const instrs = result.blocks[0].instrs;
+        // Should have prefix cleanup + tag-add + 2 original instrs = 4 total
+        expect(instrs.length).toBe(4);
+        // First two are prefix (cleanup, tag-add)
+        expect(instrs[0].kind).toBe('call_context');
+        expect(instrs[0].fn).toMatch('__sel_cleanup_');
+        expect(instrs[1].kind).toBe('call_context');
+        expect(instrs[1].fn).toMatch('__sel_tag_');
+        // First actual use keeps original selector
+        const first = instrs[2];
+        const firstSub = first.subcommands[0];
+        expect(firstSub.kind === 'as' || firstSub.kind === 'at').toBe(true);
+        if (firstSub.kind === 'as' || firstSub.kind === 'at') {
+            expect(firstSub.selector).toBe(sel);
+        }
+        // Second actual use uses tag selector
+        const second = instrs[3];
+        const secondSub = second.subcommands[0];
+        expect(secondSub.kind === 'as' || secondSub.kind === 'at').toBe(true);
+        if (secondSub.kind === 'as' || secondSub.kind === 'at') {
+            expect(secondSub.selector).toMatch(/^@e\[tag=__cache_sel_/);
+        }
+    });
+    test('does not cache simple selectors without [', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call_context', fn: 'ns:a', subcommands: [{ kind: 'as', selector: '@s' }] },
+                { kind: 'call_context', fn: 'ns:b', subcommands: [{ kind: 'as', selector: '@s' }] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, selector_cache_1.selectorCache)(fn);
+        const instrs = result.blocks[0].instrs;
+        // No change — @s is simple
+        expect(instrs).toHaveLength(2);
+        expect(instrs[0].fn).toBe('ns:a');
+        expect(instrs[1].fn).toBe('ns:b');
+    });
+    test('does not cache selector appearing only once', () => {
+        const sel = '@e[type=zombie]';
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call_context', fn: 'ns:a', subcommands: [{ kind: 'as', selector: sel }] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, selector_cache_1.selectorCache)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+    });
+    test('caches independently across blocks', () => {
+        const sel = '@e[type=zombie]';
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call_context', fn: 'ns:a', subcommands: [{ kind: 'as', selector: sel }] },
+            ], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [
+                { kind: 'call_context', fn: 'ns:b', subcommands: [{ kind: 'as', selector: sel }] },
+                { kind: 'call_context', fn: 'ns:c', subcommands: [{ kind: 'as', selector: sel }] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, selector_cache_1.selectorCache)(fn);
+        // entry block: only 1 occurrence → no change
+        expect(result.blocks[0].instrs).toHaveLength(1);
+        // b1 block: 2 occurrences → 2 prefix + 2 originals = 4
+        expect(result.blocks[1].instrs).toHaveLength(4);
+    });
+    test('handles at subcommand as well as as', () => {
+        const sel = '@e[type=creeper,distance=..5]';
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call_context', fn: 'ns:a', subcommands: [{ kind: 'at', selector: sel }] },
+                { kind: 'call_context', fn: 'ns:b', subcommands: [{ kind: 'at', selector: sel }] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, selector_cache_1.selectorCache)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs).toHaveLength(4);
+        const second = instrs[3];
+        const secondSub = second.subcommands[0];
+        expect(secondSub.kind === 'as' || secondSub.kind === 'at').toBe(true);
+        if (secondSub.kind === 'as' || secondSub.kind === 'at') {
+            expect(secondSub.selector).toMatch(/^@e\[tag=__cache_sel_/);
+        }
+    });
+});
+//# sourceMappingURL=selector-cache.test.js.map

package/dist/src/__tests__/optimizer/unroll.test.d.ts

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

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Tests for the small constant loop unrolling pass.
+ *
+ * We test through the full compiler pipeline (source → MIR → optimize)
+ * to verify realistic unroll behavior, and also test the pass directly
+ * with synthetic MIR for edge cases.
+ */
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const pipeline_1 = require("../../optimizer/pipeline");
+const unroll_1 = require("../../optimizer/unroll");
+function compileToMIR(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    const mir = (0, lower_2.lowerToMIR)(hir);
+    return mir.functions;
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+// ---------------------------------------------------------------------------
+// Synthetic MIR tests
+// ---------------------------------------------------------------------------
+describe('loopUnroll — synthetic MIR', () => {
+    /**
+     * Build a minimal for(i=0; i<N; i++) loop in MIR form:
+     *   entry: const i 0; jump → loop_header
+     *   loop_header: cmp t_cmp lt i N; branch t_cmp → loop_body / loop_exit
+     *   loop_body: [body instrs]; jump → loop_latch
+     *   loop_latch: add i i 1; jump → loop_header
+     *   loop_exit: return null
+     */
+    function buildLoop(N, bodyInstrs) {
+        return mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(N) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mkBlock('loop_body_0', bodyInstrs, { kind: 'jump', target: 'loop_latch_0' }),
+            mkBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+    }
+    test('for(i=0; i<3; i++) unrolls to 3 copies of body', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(3, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // loop_header, loop_body, loop_latch should be gone
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        expect(result.blocks.some(b => b.id.startsWith('loop_latch'))).toBe(false);
+        expect(result.blocks.some(b => b.id.startsWith('loop_body'))).toBe(false);
+        // loop_exit should still be there
+        expect(result.blocks.some(b => b.id.startsWith('loop_exit'))).toBe(true);
+        // entry block should contain 3 call instructions with substituted i values
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(instr => instr.kind === 'call');
+        expect(calls).toHaveLength(3);
+        // Each call should have i substituted as 0, 1, 2
+        expect(calls[0].args[0]).toEqual(c(0));
+        expect(calls[1].args[0]).toEqual(c(1));
+        expect(calls[2].args[0]).toEqual(c(2));
+    });
+    test('for(i=0; i<1; i++) unrolls to 1 copy', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(1, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(instr => instr.kind === 'call');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].args[0]).toEqual(c(0));
+    });
+    test('for(i=0; i<8; i++) unrolls to 8 copies (at limit)', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(8, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(instr => instr.kind === 'call');
+        expect(calls).toHaveLength(8);
+    });
+    test('for(i=0; i<9; i++) does NOT unroll (exceeds limit)', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(9, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Should not have changed — loop blocks remain
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true);
+        expect(result).toBe(fn);
+    });
+    test('for(i=0; i<10; i++) does NOT unroll', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(10, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true);
+    });
+    test('variable substitution replaces i in arithmetic', () => {
+        // Body: x = i * 2
+        const bodyInstrs = [
+            { kind: 'mul', dst: 'x', a: t('i'), b: c(2) },
+            { kind: 'call', dst: null, fn: 'test:use', args: [t('x')] },
+        ];
+        const fn = buildLoop(3, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const muls = entry.instrs.filter(instr => instr.kind === 'mul');
+        expect(muls).toHaveLength(3);
+        expect(muls[0].a).toEqual(c(0));
+        expect(muls[1].a).toEqual(c(1));
+        expect(muls[2].a).toEqual(c(2));
+    });
+    test('init must be 0 — does not unroll if initialized to non-zero', () => {
+        // entry: const i 1 (not 0)
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'i', value: 1 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('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' }),
+            mkBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mkBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn);
+    });
+    test('non-lt comparison does not unroll', () => {
+        // loop_header: cmp le (not lt)
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'le', a: t('i'), b: c(3) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mkBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mkBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn);
+    });
+});
+// ---------------------------------------------------------------------------
+// End-to-end tests via full compiler pipeline
+// ---------------------------------------------------------------------------
+describe('loopUnroll — end-to-end via optimizeFunction', () => {
+    test('for(0..3) loop is unrolled after full optimization', () => {
+        const fns = compileToMIR(`
+      fn f(): void {
+        for (let i: int = 0; i < 3; i = i + 1) {
+          cmd("say " + i);
+        }
+      }
+    `);
+        const fn = fns[0];
+        const optimized = (0, pipeline_1.optimizeFunction)(fn);
+        // After optimization, loop blocks should be gone
+        expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        expect(optimized.blocks.some(b => b.id.startsWith('loop_latch'))).toBe(false);
+    });
+    test('for(0..10) loop is NOT unrolled', () => {
+        const fns = compileToMIR(`
+      fn f(): void {
+        for (let i: int = 0; i < 10; i = i + 1) {
+          cmd("say " + i);
+        }
+      }
+    `);
+        const fn = fns[0];
+        const optimized = (0, pipeline_1.optimizeFunction)(fn);
+        // Loop blocks should remain (N=10 > limit)
+        expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true);
+    });
+});
+//# sourceMappingURL=unroll.test.js.map

package/dist/src/__tests__/option.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for Phase 6a: Option<T> — null safety
+ *
+ * Covers:
+ * - Parsing Option<T> type annotation
+ * - Parsing Some(expr) and None expressions
+ * - Parsing if let Some(x) = opt { ... }
+ * - HIR lowering of Option nodes
+ * - MIR lowering: Option compiles to two slots (has + val)
+ * - if let Some(x) = opt → checks has slot, binds val slot
+ * - Function returning Option<int>
+ * - Correct scoreboard commands generated
+ */
+export {};