redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/optimizer/auto-inline.test.d.ts

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

package/dist/src/__tests__/optimizer/auto-inline.test.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auto_inline_1 = require("../../optimizer/auto-inline");
+const pipeline_1 = require("../../optimizer/pipeline");
+function mkFn(name, params, blocks) {
+    return {
+        name,
+        params: params.map(param => ({ name: param, isMacroParam: false })),
+        blocks,
+        entry: 'entry',
+        isMacro: false,
+    };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+function mkMod(functions, extras = {}) {
+    return {
+        functions,
+        namespace: 'test',
+        objective: '__test',
+        ...extras,
+    };
+}
+const c = (value) => ({ kind: 'const', value });
+const t = (name) => ({ kind: 'temp', name });
+function getFn(mod, name) {
+    const fn = mod.functions.find(candidate => candidate.name === name);
+    if (!fn)
+        throw new Error(`Missing function ${name}`);
+    return fn;
+}
+function getAllInstrs(fn) {
+    return fn.blocks.flatMap(block => [...block.instrs, block.term]);
+}
+describe('autoInlineSmallFunctions', () => {
+    test('automatically inlines a small function without @inline', () => {
+        const addOne = mkFn('test:add_one', ['x'], [
+            mkBlock('entry', [
+                { kind: 'add', dst: 'sum', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('sum') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:add_one', args: [c(41)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, auto_inline_1.autoInlineSmallFunctions)(mkMod([main, addOne]));
+        const instrs = getAllInstrs(getFn(result, 'test:main'));
+        expect(instrs.filter(instr => instr.kind === 'call')).toHaveLength(0);
+        expect(instrs.filter(instr => instr.kind === 'add')).toHaveLength(1);
+    });
+    test('does not auto-inline functions marked @no-inline', () => {
+        const helper = mkFn('test:helper', ['x'], [
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'r', src: t('x') },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:helper', args: [c(1)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, auto_inline_1.autoInlineSmallFunctions)(mkMod([main, helper], {
+            noInlineFunctions: new Set(['test:helper']),
+        }));
+        expect(getAllInstrs(getFn(result, 'test:main')).filter(instr => instr.kind === 'call')).toHaveLength(1);
+    });
+    test('does not auto-inline functions larger than 5 MIR instructions', () => {
+        const big = mkFn('test:big', ['x'], [
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'a', src: t('x') },
+                { kind: 'add', dst: 'b', a: t('a'), b: c(1) },
+                { kind: 'mul', dst: 'c', a: t('b'), b: c(2) },
+                { kind: 'sub', dst: 'd', a: t('c'), b: c(3) },
+                { kind: 'add', dst: 'e', a: t('d'), b: c(4) },
+            ], { kind: 'return', value: t('e') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:big', args: [c(2)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, auto_inline_1.autoInlineSmallFunctions)(mkMod([main, big]));
+        expect(getAllInstrs(getFn(result, 'test:main')).filter(instr => instr.kind === 'call')).toHaveLength(1);
+    });
+    test('auto-inlines functions with exactly 5 MIR instructions', () => {
+        const exactFive = mkFn('test:exact_five', ['x'], [
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'a', src: t('x') },
+                { kind: 'add', dst: 'b', a: t('a'), b: c(1) },
+                { kind: 'mul', dst: 'c', a: t('b'), b: c(2) },
+                { kind: 'sub', dst: 'd', a: t('c'), b: c(3) },
+            ], { kind: 'return', value: t('d') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:exact_five', args: [c(2)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, auto_inline_1.autoInlineSmallFunctions)(mkMod([main, exactFive]));
+        expect(getAllInstrs(getFn(result, 'test:main')).filter(instr => instr.kind === 'call')).toHaveLength(0);
+    });
+    test('does not auto-inline directly recursive functions', () => {
+        const recur = mkFn('test:recur', ['n'], [
+            mkBlock('entry', [
+                { kind: 'sub', dst: 'n1', a: t('n'), b: c(1) },
+                { kind: 'call', dst: 'r', fn: 'test:recur', args: [t('n1')] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:recur', args: [c(3)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, auto_inline_1.autoInlineSmallFunctions)(mkMod([main, recur]));
+        expect(getAllInstrs(getFn(result, 'test:main')).filter(instr => instr.kind === 'call')).toHaveLength(1);
+    });
+    test('does not auto-inline indirectly recursive functions', () => {
+        const first = mkFn('test:first', ['n'], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:second', args: [t('n')] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const second = mkFn('test:second', ['n'], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:first', args: [t('n')] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:first', args: [c(1)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, auto_inline_1.autoInlineSmallFunctions)(mkMod([main, first, second]));
+        expect(getAllInstrs(getFn(result, 'test:main')).filter(instr => instr.kind === 'call')).toHaveLength(1);
+    });
+    test('pipeline still honors explicit @inline for larger functions', () => {
+        const explicitInline = mkFn('test:explicit', ['x'], [
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'a', src: t('x') },
+                { kind: 'add', dst: 'b', a: t('a'), b: c(1) },
+                { kind: 'mul', dst: 'c', a: t('b'), b: c(2) },
+                { kind: 'sub', dst: 'd', a: t('c'), b: c(3) },
+                { kind: 'add', dst: 'e', a: t('d'), b: c(4) },
+            ], { kind: 'return', value: t('e') }),
+        ]);
+        const main = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:explicit', args: [c(2)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const result = (0, pipeline_1.optimizeModule)(mkMod([main, explicitInline], {
+            inlineFunctions: new Set(['test:explicit']),
+        }));
+        expect(getAllInstrs(getFn(result, 'test:main')).filter(instr => instr.kind === 'call')).toHaveLength(0);
+    });
+    test('inlining before DCE removes dead code exposed by the inline', () => {
+        const id = mkFn('test:id', ['x'], [
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'r', src: t('x') },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const main = mkFn('test:main', ['p'], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'dead', fn: 'test:id', args: [t('p')] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, pipeline_1.optimizeModule)(mkMod([main, id]));
+        const instrs = getAllInstrs(getFn(result, 'test:main'));
+        expect(instrs.filter(instr => instr.kind === 'call')).toHaveLength(0);
+        expect(instrs.filter(instr => instr.kind === 'copy')).toHaveLength(0);
+        expect(getFn(result, 'test:main').blocks).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=auto-inline.test.js.map

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for Common Subexpression Elimination (CSE) pass.
+ */
+export {};

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

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Tests for Common Subexpression Elimination (CSE) pass.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cse_1 = require("../../optimizer/cse");
+function mkFn(blocks) {
+    return { name: 'test', params: [], 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('CSE — basic intra-block elimination', () => {
+    test('eliminates duplicate add within same block', () => {
+        // t0 = x + y
+        // t1 = x + y  ← should become: t1 = copy t0
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'add', dst: 't1', a: t('x'), b: t('y') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('add');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+    });
+    test('eliminates duplicate mul within same block', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: t('a'), b: c(2) },
+                { kind: 'mul', dst: 't1', a: t('a'), b: c(2) },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('mul');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+    });
+    test('eliminates duplicate cmp within same block', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: t('x'), b: c(10) },
+                { kind: 'cmp', dst: 't1', op: 'lt', a: t('x'), b: c(10) },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('cmp');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+    });
+    test('eliminates duplicate neg within same block', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'neg', dst: 't0', src: t('x') },
+                { kind: 'neg', dst: 't1', src: t('x') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('neg');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+    });
+    test('handles commutative ops (a+b == b+a)', () => {
+        // add is commutative: t('x') + t('y') == t('y') + t('x')
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'add', dst: 't1', a: t('y'), b: t('x') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('add');
+        expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } });
+    });
+});
+// ---------------------------------------------------------------------------
+describe('CSE — side effects break elimination', () => {
+    test('call instruction clears available expressions', () => {
+        // t0 = x + y
+        // call foo()     ← side effect: clears available
+        // t1 = x + y     ← must NOT be eliminated
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'call', dst: null, fn: 'foo', args: [] },
+                { kind: 'add', dst: 't1', a: t('x'), b: t('y') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[2].kind).toBe('add'); // not a copy
+    });
+    test('score_write clears available expressions', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'score_write', player: '@s', obj: 'score', src: c(5) },
+                { kind: 'add', dst: 't1', a: t('x'), b: t('y') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[2].kind).toBe('add');
+    });
+});
+// ---------------------------------------------------------------------------
+describe('CSE — different operation types don\'t match', () => {
+    test('add and sub with same operands are not equivalent', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'sub', dst: 't1', a: t('x'), b: t('y') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('add');
+        expect(instrs[1].kind).toBe('sub'); // not eliminated
+    });
+    test('cmp with different ops are not equivalent', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: t('x'), b: c(5) },
+                { kind: 'cmp', dst: 't1', op: 'gt', a: t('x'), b: c(5) },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('cmp');
+        expect(instrs[1].kind).toBe('cmp'); // not eliminated
+    });
+});
+// ---------------------------------------------------------------------------
+describe('CSE — operand redefinition invalidates', () => {
+    test('redefining an operand invalidates dependent expression', () => {
+        // t0 = x + y
+        // x  = const 99   ← x is overwritten
+        // t1 = x + y      ← x has changed, must NOT reuse t0
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'const', dst: 'x', value: 99 },
+                { kind: 'add', dst: 't1', a: t('x'), b: t('y') },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[2].kind).toBe('add'); // not a copy
+    });
+    test('multiple uses before redefinition are all eliminated', () => {
+        // t0 = x + y
+        // t1 = x + y   ← eliminated → copy t0
+        // t2 = x + y   ← also eliminated → copy t0
+        // ...then x overwritten, t3 = x+y is NOT eliminated
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: t('y') },
+                { kind: 'add', dst: 't1', a: t('x'), b: t('y') },
+                { kind: 'add', dst: 't2', a: t('x'), b: t('y') },
+                { kind: 'const', dst: 'x', value: 0 },
+                { kind: 'add', dst: 't3', a: t('x'), b: t('y') },
+            ], { kind: 'return', value: t('t3') }),
+        ]);
+        const result = (0, cse_1.cse)(fn);
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('add');
+        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' } });
+        expect(instrs[3].kind).toBe('const');
+        expect(instrs[4].kind).toBe('add');
+    });
+});
+//# sourceMappingURL=cse.test.js.map

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

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

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

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Tests for the @inline function inlining optimizer pass.
+ */
+const inline_1 = require("../../optimizer/inline");
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+function mkMod(functions, inlineFunctions) {
+    return { functions, namespace: 'test', objective: '__test', inlineFunctions };
+}
+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 });
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('inlinePass', () => {
+    test('no-op when inlineFunctions is empty', () => {
+        const fn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:add', args: [c(1), c(2)] },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const mod = mkMod([fn]); // no inlineFunctions
+        const result = (0, inline_1.inlinePass)(mod);
+        expect(result).toBe(mod); // exact same reference — nothing changed
+    });
+    test('inlines a single-block function, replacing call with inlined body', () => {
+        // fn add(a, b) { return a + b }  — @inline
+        const addFn = mkFn('test:add', ['a', 'b'], [
+            mkBlock('entry', [
+                { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+            ], { kind: 'return', value: t('result') }),
+        ]);
+        // fn main() { let r = add(3, 4); return r }
+        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], new Set(['test:add']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        // There must be no `call` instruction in main after inlining
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        const callInstrs = allInstrs.filter(i => i.kind === 'call');
+        expect(callInstrs).toHaveLength(0);
+        // The add instruction must appear somewhere (substituted: a→3, b→4)
+        const addInstrs = allInstrs.filter(i => i.kind === 'add');
+        expect(addInstrs).toHaveLength(1);
+        expect(addInstrs[0].a).toEqual(c(3));
+        expect(addInstrs[0].b).toEqual(c(4));
+        // The return value should be the result of the add (via copy into t0)
+        const copyInstrs = allInstrs.filter(i => i.kind === 'copy');
+        expect(copyInstrs.some(ci => ci.dst === 't0')).toBe(true);
+    });
+    test('inlines a multi-block callee (if/else CFG)', () => {
+        // fn clamp(val, lo, hi):
+        //   entry: branch val<lo → lo_blk else gt_blk
+        //   lo_blk: return lo
+        //   gt_blk: branch val>hi → hi_blk else mid_blk
+        //   hi_blk: return hi
+        //   mid_blk: return val
+        const clampFn = mkFn('test:clamp', ['val', 'lo', 'hi'], [
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 'lt', op: 'lt', a: t('val'), b: t('lo') },
+            ], { kind: 'branch', cond: t('lt'), then: 'lo_blk', else: 'gt_blk' }),
+            mkBlock('lo_blk', [], { kind: 'return', value: t('lo') }),
+            mkBlock('gt_blk', [
+                { kind: 'cmp', dst: 'gt', op: 'gt', a: t('val'), b: t('hi') },
+            ], { kind: 'branch', cond: t('gt'), then: 'hi_blk', else: 'mid_blk' }),
+            mkBlock('hi_blk', [], { kind: 'return', value: t('hi') }),
+            mkBlock('mid_blk', [], { kind: 'return', value: t('val') }),
+        ]);
+        const mainFn = mkFn('test:main', ['x'], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:clamp', args: [t('x'), c(0), c(100)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const mod = mkMod([mainFn, clampFn], new Set(['test:clamp']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        // No call instructions remain
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(0);
+        // Should have 5 original clamp blocks + the split entry (pre-call) + continuation
+        // clamp has 5 blocks; entry splits into pre+jump and continuation
+        expect(main.blocks.length).toBeGreaterThanOrEqual(5);
+        // cmp instructions should be present (substituted)
+        const cmpInstrs = allInstrs.filter(i => i.kind === 'cmp');
+        expect(cmpInstrs.length).toBeGreaterThanOrEqual(2);
+        // lo arg should be substituted: lo → const 0
+        const ltCmp = cmpInstrs.find(i => i.op === 'lt');
+        expect(ltCmp.b).toEqual(c(0));
+    });
+    test('does not inline recursive callee', () => {
+        // fn fact(n) { call fact(n-1); return ... }  — self-recursive
+        const factFn = mkFn('test:fact', ['n'], [
+            mkBlock('entry', [
+                { kind: 'sub', dst: 'n1', a: t('n'), b: c(1) },
+                { kind: 'call', dst: 'sub', fn: 'test:fact', args: [t('n1')] },
+                { kind: 'mul', dst: 'res', a: t('n'), b: t('sub') },
+            ], { kind: 'return', value: t('res') }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 'r', fn: 'test:fact', args: [c(5)] },
+            ], { kind: 'return', value: t('r') }),
+        ]);
+        const mod = mkMod([mainFn, factFn], new Set(['test:fact']));
+        const result = (0, inline_1.inlinePass)(mod);
+        // The call must remain since fact is recursive
+        const main = result.functions.find(f => f.name === 'test:main');
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(1);
+    });
+    test('does not inline 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], new Set(['test:mfn']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(1);
+    });
+    test('does not inline external functions (not in module)', () => {
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: null, fn: 'external:fn', args: [c(1)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mkMod([mainFn], new Set(['external:fn']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(1);
+    });
+    test('inlines multiple calls to the same 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(1), c(2)] },
+                { kind: 'call', dst: 't1', fn: 'test:add', args: [c(3), c(4)] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mkMod([mainFn, addFn], new Set(['test:add']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        // Both calls should be gone
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(0);
+        // Two add instructions (one from each inlined call)
+        expect(allInstrs.filter(i => i.kind === 'add')).toHaveLength(2);
+    });
+    test('does not inline function not in inlineFunctions set', () => {
+        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: 'return', value: t('t0') }),
+        ]);
+        // add is NOT in the inline set
+        const mod = mkMod([mainFn, addFn], new Set(['test:other']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(1);
+    });
+    test('inlines void function (null dst)', () => {
+        // fn greet() { say("hi") via nbt_write side-effects; return; }
+        const greetFn = mkFn('test:greet', [], [
+            mkBlock('entry', [
+                { kind: 'nbt_write', ns: 'greet', path: 'msg', type: 'int', scale: 1, src: c(1) },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mainFn = mkFn('test:main', [], [
+            mkBlock('entry', [
+                { kind: 'call', dst: null, fn: 'test:greet', args: [] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const mod = mkMod([mainFn, greetFn], new Set(['test:greet']));
+        const result = (0, inline_1.inlinePass)(mod);
+        const main = result.functions.find(f => f.name === 'test:main');
+        const allInstrs = main.blocks.flatMap(b => [...b.instrs, b.term]);
+        expect(allInstrs.filter(i => i.kind === 'call')).toHaveLength(0);
+        // nbt_write should be present from inlined body
+        expect(allInstrs.filter(i => i.kind === 'nbt_write')).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=inline_fn.test.js.map

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

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