redscript-mc 1.2.30 → 2.1.0

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

@@ -0,0 +1,116 @@
+import { optimizeFunction, optimizeModule } from '../../optimizer/pipeline'
+import type { MIRFunction, MIRBlock, MIRInstr, MIRModule, 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('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 = 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 = 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 = 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: MIRModule = {
+      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 = 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 = 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) })
+  })
+})

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

@@ -0,0 +1,112 @@
+import { selectorCache } from '../../optimizer/selector-cache'
+import type { MIRFunction, MIRBlock, MIRInstr } 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: [] }
+}
+
+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 = 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] as any).fn).toMatch('__sel_cleanup_')
+    expect(instrs[1].kind).toBe('call_context')
+    expect((instrs[1] as any).fn).toMatch('__sel_tag_')
+
+    // First actual use keeps original selector
+    const first = instrs[2] as Extract<MIRInstr, { kind: 'call_context' }>
+    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] as Extract<MIRInstr, { kind: 'call_context' }>
+    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 = selectorCache(fn)
+    const instrs = result.blocks[0].instrs
+    // No change — @s is simple
+    expect(instrs).toHaveLength(2)
+    expect((instrs[0] as any).fn).toBe('ns:a')
+    expect((instrs[1] as any).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 = 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 = 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 = selectorCache(fn)
+    const instrs = result.blocks[0].instrs
+    expect(instrs).toHaveLength(4)
+    const second = instrs[3] as Extract<MIRInstr, { kind: 'call_context' }>
+    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_/)
+    }
+  })
+})

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

@@ -0,0 +1,231 @@
+/**
+ * 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.
+ */
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { optimizeFunction } from '../../optimizer/pipeline'
+import { loopUnroll } from '../../optimizer/unroll'
+import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+function compileToMIR(source: string): MIRFunction[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  const hir = lowerToHIR(ast)
+  const mir = lowerToMIR(hir)
+  return mir.functions
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr, preds: string[] = []): MIRBlock {
+  return { id, instrs, term, preds }
+}
+
+function mkFn(blocks: MIRBlock[]): MIRFunction {
+  return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false }
+}
+
+const c = (v: number): Operand => ({ kind: 'const', value: v })
+const t = (n: string): Operand => ({ 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: number, bodyInstrs: MIRInstr[]): MIRFunction {
+    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: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(3, bodyInstrs)
+    const result = 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] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(0))
+    expect((calls[1] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(1))
+    expect((calls[2] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(2))
+  })
+
+  test('for(i=0; i<1; i++) unrolls to 1 copy', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(1, bodyInstrs)
+    const result = 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] as Extract<MIRInstr, { kind: 'call' }>).args[0]).toEqual(c(0))
+  })
+
+  test('for(i=0; i<8; i++) unrolls to 8 copies (at limit)', () => {
+    const bodyInstrs: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(8, bodyInstrs)
+    const result = 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: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(9, bodyInstrs)
+    const result = 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: MIRInstr[] = [
+      { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+    ]
+    const fn = buildLoop(10, bodyInstrs)
+    const result = 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: MIRInstr[] = [
+      { 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 = loopUnroll(fn)
+
+    const entry = result.blocks.find(b => b.id === 'entry')!
+    const muls = entry.instrs.filter(instr => instr.kind === 'mul') as Extract<MIRInstr, { 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 = 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 = 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 = 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 = optimizeFunction(fn)
+
+    // Loop blocks should remain (N=10 > limit)
+    expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true)
+  })
+})