redscript-mc 2.6.2 → 3.0.1

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

@@ -0,0 +1,206 @@
+import { autoInlineSmallFunctions } from '../../optimizer/auto-inline'
+import { optimizeModule } from '../../optimizer/pipeline'
+import type { MIRBlock, MIRFunction, MIRInstr, MIRModule, Operand } from '../../mir/types'
+
+function mkFn(name: string, params: string[], blocks: MIRBlock[]): MIRFunction {
+  return {
+    name,
+    params: params.map(param => ({ name: param, isMacroParam: false })),
+    blocks,
+    entry: 'entry',
+    isMacro: false,
+  }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr): MIRBlock {
+  return { id, instrs, term, preds: [] }
+}
+
+function mkMod(
+  functions: MIRFunction[],
+  extras: Partial<Pick<MIRModule, 'inlineFunctions' | 'noInlineFunctions'>> = {},
+): MIRModule {
+  return {
+    functions,
+    namespace: 'test',
+    objective: '__test',
+    ...extras,
+  }
+}
+
+const c = (value: number): Operand => ({ kind: 'const', value })
+const t = (name: string): Operand => ({ kind: 'temp', name })
+
+function getFn(mod: MIRModule, name: string): MIRFunction {
+  const fn = mod.functions.find(candidate => candidate.name === name)
+  if (!fn) throw new Error(`Missing function ${name}`)
+  return fn
+}
+
+function getAllInstrs(fn: MIRFunction): MIRInstr[] {
+  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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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)
+  })
+})

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

@@ -0,0 +1,195 @@
+/**
+ * Tests for Common Subexpression Elimination (CSE) pass.
+ */
+
+import { cse } from '../../optimizer/cse'
+import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+function mkFn(blocks: MIRBlock[]): MIRFunction {
+  return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr): MIRBlock {
+  return { id, instrs, term, preds: [] }
+}
+
+const c = (v: number): Operand => ({ kind: 'const', value: v })
+const t = (n: string): Operand => ({ 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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')
+  })
+})

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

@@ -0,0 +1,263 @@
+/**
+ * Tests for the @inline function inlining optimizer pass.
+ */
+import { inlinePass } from '../../optimizer/inline'
+import type { MIRFunction, MIRModule, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function mkMod(functions: MIRFunction[], inlineFunctions?: Set<string>): MIRModule {
+  return { functions, namespace: 'test', objective: '__test', inlineFunctions }
+}
+
+function mkFn(name: string, params: string[], blocks: MIRBlock[]): MIRFunction {
+  return {
+    name,
+    params: params.map(p => ({ name: p, isMacroParam: false })),
+    blocks,
+    entry: 'entry',
+    isMacro: false,
+  }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr): MIRBlock {
+  return { id, instrs, term, preds: [] }
+}
+
+const c = (v: number): Operand => ({ kind: 'const', value: v })
+const t = (n: string): Operand => ({ 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 = 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 = 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') as Extract<MIRInstr, { 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') as Extract<MIRInstr, { 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 = 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') as Extract<MIRInstr, { 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 = 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: MIRFunction = {
+      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 = 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 = 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 = 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 = 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 = 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)
+  })
+})