redscript-mc 1.2.30 → 2.1.0

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

@@ -0,0 +1,99 @@
+import { copyProp } from '../../optimizer/copy_prop'
+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('copy propagation', () => {
+  test('propagates copy into subsequent use', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'copy', dst: 'x', src: t('y') },
+        { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('z') }),
+    ])
+    const result = copyProp(fn)
+    const add = result.blocks[0].instrs[1]
+    expect(add.kind).toBe('add')
+    expect((add as any).a).toEqual(t('y'))
+  })
+
+  test('propagates into terminator', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'copy', dst: 'x', src: t('y') },
+      ], { kind: 'return', value: t('x') }),
+    ])
+    const result = copyProp(fn)
+    expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('y') })
+  })
+
+  test('invalidates mapping when source is redefined', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'copy', dst: 'x', src: t('y') },
+        { kind: 'const', dst: 'y', value: 99 },
+        { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('z') }),
+    ])
+    const result = copyProp(fn)
+    // x's mapping was invalidated because y was redefined
+    const add = result.blocks[0].instrs[2]
+    expect((add as any).a).toEqual(t('x'))
+  })
+
+  test('propagates const definitions into uses', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 'x', value: 42 },
+        { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('z') }),
+    ])
+    const result = copyProp(fn)
+    const add = result.blocks[0].instrs[1]
+    expect((add as any).a).toEqual(c(42))
+  })
+
+  test('propagates copy-of-const into uses', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'copy', dst: 'x', src: c(42) },
+        { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('z') }),
+    ])
+    const result = copyProp(fn)
+    const add = result.blocks[0].instrs[1]
+    expect((add as any).a).toEqual(c(42))
+  })
+
+  test('chains propagation: x=y, z=x → z uses y', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'copy', dst: 'x', src: t('y') },
+        { kind: 'copy', dst: 'z', src: t('x') },
+      ], { kind: 'return', value: t('z') }),
+    ])
+    const result = copyProp(fn)
+    // z = copy x → rewritten to z = copy y
+    // then return z → rewritten to return y
+    expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('y') })
+  })
+
+  test('propagates into branch condition', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'copy', dst: 'c', src: t('flag') },
+      ], { kind: 'branch', cond: t('c'), then: 'b1', else: 'b2' }),
+    ])
+    const result = copyProp(fn)
+    expect(result.blocks[0].term).toEqual({ kind: 'branch', cond: t('flag'), then: 'b1', else: 'b2' })
+  })
+})

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

@@ -0,0 +1,312 @@
+/**
+ * Tests for the coroutine transform pass.
+ *
+ * Verifies:
+ * - Loop-containing functions are split into continuations
+ * - Dispatcher @tick function is generated
+ * - batch parameter controls iteration count
+ * - onDone callback is called when coroutine completes
+ * - Variables live across yield points are promoted
+ * - Functions without loops get single-continuation wrapping
+ */
+
+import { coroutineTransform, type CoroutineInfo } from '../../optimizer/coroutine'
+import type { MIRFunction, MIRModule, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function mkFn(name: string, blocks: MIRBlock[], entry = 'entry'): MIRFunction {
+  return { name, params: [], blocks, entry, isMacro: false }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr, preds: string[] = []): MIRBlock {
+  return { id, instrs, term, preds }
+}
+
+function mkModule(functions: MIRFunction[], namespace = 'test'): MIRModule {
+  return { functions, namespace, objective: `__${namespace}` }
+}
+
+const c = (v: number): Operand => ({ kind: 'const', value: v })
+const t = (n: string): Operand => ({ kind: 'temp', name: n })
+
+/**
+ * Build a simple loop function:
+ *   let i = 0;
+ *   while (i < limit) { call do_work(i); i++; }
+ *   return;
+ *
+ * CFG:
+ *   entry → header → body → header (back edge)
+ *                  → exit
+ */
+function mkLoopFn(name: string, limit = 1000): MIRFunction {
+  return mkFn(name, [
+    mkBlock('entry', [
+      { kind: 'const', dst: 'i', value: 0 },
+    ], { kind: 'jump', target: 'header' }),
+
+    mkBlock('header', [
+      { kind: 'cmp', dst: 'cond', op: 'lt', a: t('i'), b: c(limit) },
+    ], { kind: 'branch', cond: t('cond'), then: 'body', else: 'exit' }, ['entry', 'body']),
+
+    mkBlock('body', [
+      { kind: 'call', dst: null, fn: 'do_work', args: [t('i')] },
+      { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+    ], { kind: 'jump', target: 'header' }, ['header']),
+
+    mkBlock('exit', [], { kind: 'return', value: null }, ['header']),
+  ])
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('coroutine transform', () => {
+  describe('basic loop splitting', () => {
+    test('splits a loop function into continuations + dispatcher', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      // Should have: init fn (process_all), at least 1 continuation, dispatcher
+      const fnNames = result.module.functions.map(f => f.name)
+      expect(fnNames).toContain('process_all') // init function
+      expect(fnNames).toContain('_coro_process_all_tick') // dispatcher
+
+      // Should have at least one continuation
+      const contFns = fnNames.filter(n => n.includes('_coro_process_all_cont_'))
+      expect(contFns.length).toBeGreaterThanOrEqual(1)
+    })
+
+    test('dispatcher is added to generatedTickFunctions', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      expect(result.generatedTickFunctions).toContain('_coro_process_all_tick')
+    })
+
+    test('init function sets pc = 1', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      const initFn = result.module.functions.find(f => f.name === 'process_all')!
+      expect(initFn).toBeDefined()
+
+      // Init function should have a const instruction setting pc = 1
+      const allInstrs = initFn.blocks.flatMap(b => b.instrs)
+      const pcSet = allInstrs.find(i =>
+        i.kind === 'const' && i.dst.includes('_pc') && i.value === 1
+      )
+      expect(pcSet).toBeDefined()
+    })
+
+    test('init function ends with return', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      const initFn = result.module.functions.find(f => f.name === 'process_all')!
+      const lastBlock = initFn.blocks[initFn.blocks.length - 1]
+      expect(lastBlock.term.kind).toBe('return')
+    })
+  })
+
+  describe('dispatcher generation', () => {
+    test('dispatcher checks pc for each continuation', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      const dispatcher = result.module.functions.find(f => f.name === '_coro_process_all_tick')!
+      expect(dispatcher).toBeDefined()
+
+      // Dispatcher should contain cmp instructions checking pc
+      const allInstrs = dispatcher.blocks.flatMap(b => b.instrs)
+      const cmpInstrs = allInstrs.filter(i => i.kind === 'cmp')
+      expect(cmpInstrs.length).toBeGreaterThanOrEqual(1)
+
+      // Dispatcher should call continuation functions
+      const callInstrs = allInstrs.filter(i => i.kind === 'call')
+      expect(callInstrs.length).toBeGreaterThanOrEqual(1)
+      for (const call of callInstrs) {
+        if (call.kind === 'call') {
+          expect(call.fn).toContain('_coro_process_all_cont_')
+        }
+      }
+    })
+  })
+
+  describe('batch parameter', () => {
+    test('continuation contains batch counting logic', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 5 }
+      const result = coroutineTransform(mod, [info])
+
+      // Find the loop continuation
+      const contFn = result.module.functions.find(f => f.name.includes('_cont_'))!
+      expect(contFn).toBeDefined()
+
+      // Should contain batch count initialization (const 0)
+      const allInstrs = contFn.blocks.flatMap(b => b.instrs)
+      const batchInit = allInstrs.find(i =>
+        i.kind === 'const' && i.dst.includes('batch_count') && i.value === 0
+      )
+      expect(batchInit).toBeDefined()
+
+      // Should contain batch comparison (cmp ge against batch value)
+      const batchCmp = allInstrs.find(i =>
+        i.kind === 'cmp' && i.op === 'ge'
+      )
+      expect(batchCmp).toBeDefined()
+      if (batchCmp && batchCmp.kind === 'cmp') {
+        expect(batchCmp.b).toEqual(c(5))
+      }
+    })
+
+    test('different batch values produce different comparison constants', () => {
+      const mod1 = mkModule([mkLoopFn('fn1')])
+      const mod2 = mkModule([mkLoopFn('fn2')])
+
+      const result1 = coroutineTransform(mod1, [{ fnName: 'fn1', batch: 10 }])
+      const result2 = coroutineTransform(mod2, [{ fnName: 'fn2', batch: 50 }])
+
+      const cont1 = result1.module.functions.find(f => f.name.includes('_cont_'))!
+      const cont2 = result2.module.functions.find(f => f.name.includes('_cont_'))!
+
+      const batchCmp1 = cont1.blocks.flatMap(b => b.instrs).find(i =>
+        i.kind === 'cmp' && i.op === 'ge'
+      )
+      const batchCmp2 = cont2.blocks.flatMap(b => b.instrs).find(i =>
+        i.kind === 'cmp' && i.op === 'ge'
+      )
+
+      expect(batchCmp1).toBeDefined()
+      expect(batchCmp2).toBeDefined()
+      if (batchCmp1?.kind === 'cmp' && batchCmp2?.kind === 'cmp') {
+        expect(batchCmp1.b).toEqual(c(10))
+        expect(batchCmp2.b).toEqual(c(50))
+      }
+    })
+  })
+
+  describe('onDone callback', () => {
+    test('generates call to onDone function when coroutine completes', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10, onDone: 'after_process' }
+      const result = coroutineTransform(mod, [info])
+
+      // Find post-loop continuation or the exit path
+      // onDone should appear as a call instruction somewhere in the continuations
+      const allFns = result.module.functions.filter(f => f.name.includes('_cont_'))
+      const allInstrs = allFns.flatMap(f => f.blocks.flatMap(b => b.instrs))
+      const onDoneCall = allInstrs.find(i =>
+        i.kind === 'call' && i.fn === 'after_process'
+      )
+      expect(onDoneCall).toBeDefined()
+    })
+
+    test('no onDone call when onDone is not specified', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      const allFns = result.module.functions.filter(f => f.name.includes('_cont_'))
+      const allInstrs = allFns.flatMap(f => f.blocks.flatMap(b => b.instrs))
+      const unexpectedCall = allInstrs.find(i =>
+        i.kind === 'call' && i.fn === 'after_process'
+      )
+      expect(unexpectedCall).toBeUndefined()
+    })
+  })
+
+  describe('variable promotion', () => {
+    test('live variables at yield points get promoted names', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      // The loop variable 'i' should be promoted to a persistent name
+      const contFn = result.module.functions.find(f => f.name.includes('_cont_'))!
+      const allInstrs = contFn.blocks.flatMap(b => [...b.instrs, b.term])
+
+      // Check that promoted variable names contain the coroutine prefix
+      const hasPromoted = allInstrs.some(i => {
+        if (i.kind === 'call' && i.args.length > 0) {
+          return i.args.some(a => a.kind === 'temp' && a.name.includes('_coro_'))
+        }
+        return false
+      })
+      expect(hasPromoted).toBe(true)
+    })
+  })
+
+  describe('no-loop functions', () => {
+    test('function without loops gets single-continuation wrapping', () => {
+      const fn = mkFn('simple', [
+        mkBlock('entry', [
+          { kind: 'call', dst: null, fn: 'do_something', args: [] },
+        ], { kind: 'return', value: null }),
+      ])
+      const mod = mkModule([fn])
+      const info: CoroutineInfo = { fnName: 'simple', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      const fnNames = result.module.functions.map(f => f.name)
+      expect(fnNames).toContain('simple')
+      expect(fnNames).toContain('_coro_simple_tick')
+      expect(fnNames).toContain('_coro_simple_cont_1')
+    })
+
+    test('no-loop function with onDone calls onDone', () => {
+      const fn = mkFn('simple', [
+        mkBlock('entry', [
+          { kind: 'call', dst: null, fn: 'work', args: [] },
+        ], { kind: 'return', value: null }),
+      ])
+      const mod = mkModule([fn])
+      const info: CoroutineInfo = { fnName: 'simple', batch: 10, onDone: 'callback' }
+      const result = coroutineTransform(mod, [info])
+
+      const cont = result.module.functions.find(f => f.name === '_coro_simple_cont_1')!
+      const allInstrs = cont.blocks.flatMap(b => b.instrs)
+      const onDoneCall = allInstrs.find(i => i.kind === 'call' && i.fn === 'callback')
+      expect(onDoneCall).toBeDefined()
+    })
+  })
+
+  describe('non-coroutine functions are unchanged', () => {
+    test('functions not in coroutine list pass through untouched', () => {
+      const fn1 = mkFn('helper', [
+        mkBlock('entry', [
+          { kind: 'const', dst: 't0', value: 42 },
+        ], { kind: 'return', value: t('t0') }),
+      ])
+      const fn2 = mkLoopFn('process_all')
+      const mod = mkModule([fn1, fn2])
+      const info: CoroutineInfo = { fnName: 'process_all', batch: 10 }
+      const result = coroutineTransform(mod, [info])
+
+      // helper should be in the output unchanged
+      const helper = result.module.functions.find(f => f.name === 'helper')!
+      expect(helper).toBeDefined()
+      expect(helper.blocks).toHaveLength(1)
+      expect(helper.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 42 })
+    })
+  })
+
+  describe('empty coroutine list', () => {
+    test('returns module unchanged when no coroutines', () => {
+      const mod = mkModule([mkLoopFn('process_all')])
+      const result = coroutineTransform(mod, [])
+
+      expect(result.module).toBe(mod) // same reference
+      expect(result.generatedTickFunctions).toEqual([])
+    })
+  })
+})

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

@@ -0,0 +1,83 @@
+import { dce } from '../../optimizer/dce'
+import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+function mkFn(blocks: MIRBlock[], entry = 'entry'): MIRFunction {
+  return { name: 'test', params: [], blocks, entry, isMacro: false }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr, preds: string[] = []): 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('dead code elimination', () => {
+  test('removes unused temp definition', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 'dead', value: 42 },
+        { kind: 'const', dst: 'live', value: 1 },
+      ], { kind: 'return', value: t('live') }),
+    ])
+    const result = dce(fn)
+    expect(result.blocks[0].instrs).toHaveLength(1)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 'live', value: 1 })
+  })
+
+  test('keeps side-effectful instructions even if dst unused', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'call', dst: 'unused', fn: 'sideEffect', args: [] },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = dce(fn)
+    expect(result.blocks[0].instrs).toHaveLength(1)
+  })
+
+  test('removes unreachable blocks', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'return', value: null }),
+      mkBlock('dead_block', [
+        { kind: 'const', dst: 't0', value: 99 },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = dce(fn)
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].id).toBe('entry')
+  })
+
+  test('keeps reachable blocks', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 't0', value: 1 },
+      ], { kind: 'branch', cond: t('t0'), then: 'b1', else: 'b2' }),
+      mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+      mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+    ])
+    const result = dce(fn)
+    expect(result.blocks).toHaveLength(3)
+  })
+
+  test('recomputes preds after block removal', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+      mkBlock('dead', [], { kind: 'jump', target: 'b1' }),
+    ])
+    const result = dce(fn)
+    expect(result.blocks).toHaveLength(2)
+    const b1 = result.blocks.find(b => b.id === 'b1')!
+    expect(b1.preds).toEqual(['entry'])
+  })
+
+  test('keeps nbt_write even though it has no dst', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_write', ns: 'rs:data', path: 'x', type: 'int', scale: 1, src: c(5) },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = dce(fn)
+    expect(result.blocks[0].instrs).toHaveLength(1)
+  })
+})

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

@@ -0,0 +1,174 @@
+import { interproceduralConstProp } from '../../optimizer/interprocedural'
+import type { MIRFunction, MIRModule, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+function mkMod(functions: MIRFunction[]): MIRModule {
+  return { functions, namespace: 'test', objective: '__test' }
+}
+
+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 })
+
+describe('interproceduralConstProp', () => {
+  test('specializes callee when all args are constants', () => {
+    // fn add(a, b) { return a + b }
+    // fn main() { call add(3, 4) }
+    const addFn = mkFn('test:add', ['a', 'b'], [
+      mkBlock('entry', [
+        { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+      ], { kind: 'return', value: t('result') }),
+    ])
+
+    const mainFn = mkFn('test:main', [], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:add', args: [c(3), c(4)] },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const mod = mkMod([mainFn, addFn])
+    const result = interproceduralConstProp(mod)
+
+    // Should have a specialized function
+    const specializedName = 'test:add__const_3_4'
+    const specialized = result.functions.find(f => f.name === specializedName)
+    expect(specialized).toBeDefined()
+
+    // Specialized function should have no params
+    expect(specialized!.params).toHaveLength(0)
+
+    // Specialized function should have constant-folded result: add(3,4) → 7
+    const entry = specialized!.blocks[0]
+    const returnInstr = entry.term as Extract<MIRInstr, { kind: 'return' }>
+    // After const fold, the add(3,4) becomes const 7, and return references it
+    const resultInstr = entry.instrs.find(i => i.kind === 'const' && (i as any).value === 7)
+    expect(resultInstr).toBeDefined()
+  })
+
+  test('rewrites call site to use specialized function', () => {
+    const addFn = mkFn('test:add', ['a', 'b'], [
+      mkBlock('entry', [
+        { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+      ], { kind: 'return', value: t('result') }),
+    ])
+
+    const mainFn = mkFn('test:main', [], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:add', args: [c(3), c(4)] },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const mod = mkMod([mainFn, addFn])
+    const result = interproceduralConstProp(mod)
+
+    const main = result.functions.find(f => f.name === 'test:main')!
+    const callInstr = main.blocks[0].instrs.find(i => i.kind === 'call') as Extract<MIRInstr, { kind: 'call' }>
+    expect(callInstr.fn).toBe('test:add__const_3_4')
+    expect(callInstr.args).toHaveLength(0)
+  })
+
+  test('does not specialize when args are not all constants', () => {
+    const addFn = mkFn('test:add', ['a', 'b'], [
+      mkBlock('entry', [
+        { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+      ], { kind: 'return', value: t('result') }),
+    ])
+
+    const mainFn = mkFn('test:main', [], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:add', args: [t('x'), c(4)] },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const mod = mkMod([mainFn, addFn])
+    const result = interproceduralConstProp(mod)
+
+    // No specialization created
+    expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false)
+  })
+
+  test('does not specialize 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])
+    const result = interproceduralConstProp(mod)
+    expect(result.functions.some(f => f.name.includes('__const_'))).toBe(false)
+  })
+
+  test('does not specialize external functions (not in module)', () => {
+    const mainFn = mkFn('test:main', [], [
+      mkBlock('entry', [
+        { kind: 'call', dst: null, fn: 'external:fn', args: [c(1), c(2)] },
+      ], { kind: 'return', value: null }),
+    ])
+
+    const mod = mkMod([mainFn])
+    const result = interproceduralConstProp(mod)
+    expect(result.functions).toHaveLength(1)
+  })
+
+  test('mangles negative constant args with n prefix', () => {
+    const addFn = mkFn('test:add', ['a'], [
+      mkBlock('entry', [
+        { kind: 'neg', dst: 'result', src: t('a') },
+      ], { kind: 'return', value: t('result') }),
+    ])
+
+    const mainFn = mkFn('test:main', [], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:add', args: [c(-5)] },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const mod = mkMod([mainFn, addFn])
+    const result = interproceduralConstProp(mod)
+
+    const specialized = result.functions.find(f => f.name === 'test:add__const_n5')
+    expect(specialized).toBeDefined()
+  })
+
+  test('does not create duplicate specializations', () => {
+    const addFn = mkFn('test:add', ['a', 'b'], [
+      mkBlock('entry', [
+        { kind: 'add', dst: 'result', a: t('a'), b: t('b') },
+      ], { kind: 'return', value: t('result') }),
+    ])
+
+    const mainFn = mkFn('test:main', [], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:add', args: [c(1), c(2)] },
+        { kind: 'call', dst: 't1', fn: 'test:add', args: [c(1), c(2)] },
+      ], { kind: 'return', value: null }),
+    ])
+
+    const mod = mkMod([mainFn, addFn])
+    const result = interproceduralConstProp(mod)
+
+    const specialized = result.functions.filter(f => f.name === 'test:add__const_1_2')
+    expect(specialized).toHaveLength(1)
+  })
+})