redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/optimizer/scoreboard-batch.test.ts

@@ -0,0 +1,141 @@
+import { scoreboardBatchRead } from '../../optimizer/scoreboard-batch'
+import type { MIRBlock, MIRFunction, 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 t = (name: string): Operand => ({ kind: 'temp', name })
+
+describe('scoreboardBatchRead', () => {
+  test('deduplicates repeated score_read of same player+obj', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'A', obj: 'rs.vars' },
+        { kind: 'score_read', dst: 't1', player: 'A', obj: 'rs.vars' },
+      ], { kind: 'return', value: t('t1') }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[0]).toEqual({ kind: 'score_read', dst: 't0', player: 'A', obj: 'rs.vars' })
+    expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } })
+  })
+
+  test('three reads — second and third become copies', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'X', obj: 'obj' },
+        { kind: 'score_read', dst: 't1', player: 'X', obj: 'obj' },
+        { kind: 'score_read', dst: 't2', player: 'X', obj: 'obj' },
+      ], { kind: 'return', value: null }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[0].kind).toBe('score_read')
+    expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } })
+    expect(instrs[2]).toEqual({ kind: 'copy', dst: 't2', src: { kind: 'temp', name: 't0' } })
+  })
+
+  test('score_write invalidates cache — read after write is not deduplicated', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'A', obj: 'rs.vars' },
+        { kind: 'score_write', player: 'A', obj: 'rs.vars', src: { kind: 'const', value: 42 } },
+        { kind: 'score_read', dst: 't1', player: 'A', obj: 'rs.vars' },
+      ], { kind: 'return', value: t('t1') }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[0].kind).toBe('score_read')
+    expect(instrs[1].kind).toBe('score_write')
+    expect(instrs[2].kind).toBe('score_read')
+  })
+
+  test('call clears entire cache — read after call is not deduplicated', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'A', obj: 'rs.vars' },
+        { kind: 'call', dst: null, fn: 'some_fn', args: [] },
+        { kind: 'score_read', dst: 't1', player: 'A', obj: 'rs.vars' },
+      ], { kind: 'return', value: t('t1') }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[0].kind).toBe('score_read')
+    expect(instrs[1].kind).toBe('call')
+    expect(instrs[2].kind).toBe('score_read')
+  })
+
+  test('call_macro clears entire cache', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'B', obj: 'obj' },
+        { kind: 'call_macro', dst: null, fn: 'macro_fn', args: [] },
+        { kind: 'score_read', dst: 't1', player: 'B', obj: 'obj' },
+      ], { kind: 'return', value: null }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[2].kind).toBe('score_read')
+  })
+
+  test('different objectives are not merged', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'A', obj: 'obj1' },
+        { kind: 'score_read', dst: 't1', player: 'A', obj: 'obj2' },
+      ], { kind: 'return', value: null }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[0].kind).toBe('score_read')
+    expect(instrs[1].kind).toBe('score_read')
+  })
+
+  test('different players are not merged', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'Alice', obj: 'rs.vars' },
+        { kind: 'score_read', dst: 't1', player: 'Bob', obj: 'rs.vars' },
+      ], { kind: 'return', value: null }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+
+    expect(instrs[0].kind).toBe('score_read')
+    expect(instrs[1].kind).toBe('score_read')
+  })
+
+  test('cache does not carry across blocks', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'score_read', dst: 't0', player: 'A', obj: 'rs.vars' },
+      ], { kind: 'jump', target: 'next' }),
+      mkBlock('next', [
+        { kind: 'score_read', dst: 't1', player: 'A', obj: 'rs.vars' },
+      ], { kind: 'return', value: t('t1') }),
+    ])
+
+    const result = scoreboardBatchRead(fn)
+
+    expect(result.blocks[0].instrs[0].kind).toBe('score_read')
+    expect(result.blocks[1].instrs[0].kind).toBe('score_read')
+  })
+})

package/src/__tests__/optimizer/strength-reduction.test.ts

@@ -0,0 +1,111 @@
+import { strengthReduction } from '../../optimizer/strength_reduction'
+import type { MIRBlock, MIRFunction, 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 = (value: number): Operand => ({ kind: 'const', value })
+const t = (name: string): Operand => ({ kind: 'temp', name })
+
+describe('strength reduction', () => {
+  test('rewrites x * 2 to x + x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'mul', dst: 't0', a: t('x'), b: c(2) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'add', dst: 't0', a: t('x'), b: t('x') })
+  })
+
+  test('rewrites x * 1 to x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'mul', dst: 't0', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') })
+  })
+
+  test('rewrites x * 0 to 0', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'mul', dst: 't0', a: t('x'), b: c(0) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 0 })
+  })
+
+  test('rewrites x + 0 to x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'add', dst: 't0', a: t('x'), b: c(0) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') })
+  })
+
+  test('rewrites x - 0 to x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'sub', dst: 't0', a: t('x'), b: c(0) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') })
+  })
+
+  test('rewrites x / 1 to x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'div', dst: 't0', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') })
+  })
+
+  test('rewrites x ^ 1 to x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'pow', dst: 't0', a: t('x'), b: c(1) } as unknown as MIRInstr,
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') })
+  })
+
+  test('rewrites x * -1 to -x', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'mul', dst: 't0', a: t('x'), b: c(-1) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+
+    const result = strengthReduction(fn)
+
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'neg', dst: 't0', src: t('x') })
+  })
+})

package/src/__tests__/optimizer/tco-coverage.test.ts

@@ -0,0 +1,309 @@
+/**
+ * Extended coverage tests for src/optimizer/tco.ts
+ * Targets uncovered branches: multi-param TCO, mixed returns, macro skip,
+ * empty body, single-block functions, no call in block, null return, etc.
+ */
+
+import { tailCallOptimize, findTailCallBlocks } from '../../optimizer/tco'
+import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const c = (v: number): Operand => ({ kind: 'const', value: v })
+const t = (n: string): Operand => ({ kind: 'temp', name: n })
+
+function mkFn(
+  name: string,
+  params: string[],
+  blocks: MIRBlock[],
+  isMacro = false,
+): MIRFunction {
+  return {
+    name,
+    params: params.map(p => ({ name: p, isMacroParam: false })),
+    blocks,
+    entry: 'entry',
+    isMacro,
+  }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr, preds: string[] = []): MIRBlock {
+  return { id, instrs, term, preds }
+}
+
+function countCalls(fn: MIRFunction, target: string): number {
+  return fn.blocks
+    .flatMap(b => [...b.instrs, b.term])
+    .filter(i => i.kind === 'call' && (i as Extract<MIRInstr, { kind: 'call' }>).fn === target)
+    .length
+}
+
+// ---------------------------------------------------------------------------
+// Edge case: empty function body (no blocks)
+// ---------------------------------------------------------------------------
+
+describe('tailCallOptimize — empty-like functions', () => {
+  test('function with no blocks returns unchanged', () => {
+    const fn = mkFn('test:empty', ['x'], [])
+    const result = tailCallOptimize(fn)
+    expect(result).toBe(fn)
+  })
+
+  test('function with single block that has no calls', () => {
+    const fn = mkFn('test:noreturn', ['x'], [
+      mkBlock('entry', [
+        { kind: 'const', dst: 't0', value: 42 },
+      ], { kind: 'return', value: c(42) }),
+    ])
+    const result = tailCallOptimize(fn)
+    expect(result).toBe(fn) // no tail calls, unchanged
+  })
+
+  test('function with only one block but non-self call', () => {
+    const fn = mkFn('test:single', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'other:fn', args: [t('x')] },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+    const result = tailCallOptimize(fn)
+    expect(result).toBe(fn)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Edge case: macro functions skipped
+// ---------------------------------------------------------------------------
+
+describe('tailCallOptimize — macro functions', () => {
+  test('macro function with self-call is still skipped', () => {
+    const fn = mkFn('test:macro_recurse', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:macro_recurse', args: [t('x')] },
+      ], { kind: 'return', value: t('t0') }),
+    ], /* isMacro= */ true)
+
+    const tailBlocks = findTailCallBlocks(fn)
+    // findTailCallBlocks itself doesn't check isMacro, but tailCallOptimize does
+    const result = tailCallOptimize(fn)
+    expect(result).toBe(fn) // exact same reference
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Multi-parameter tail recursion (3 params)
+// ---------------------------------------------------------------------------
+
+describe('tailCallOptimize — multi-param', () => {
+  test('3-param tail-recursive function is optimized', () => {
+    // fn fold(n, acc, step):
+    //   entry: cmp n<=0 → base/recurse
+    //   base: return acc
+    //   recurse: t1=acc+step; t2=n-1; t3=fold(t2,t1,step); return t3
+    const fn = mkFn('test:fold', ['n', 'acc', 'step'], [
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(0) },
+      ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'recurse' }),
+
+      mkBlock('base', [], { kind: 'return', value: t('acc') }),
+
+      mkBlock('recurse', [
+        { kind: 'add', dst: 't1', a: t('acc'), b: t('step') },
+        { kind: 'sub', dst: 't2', a: t('n'), b: c(1) },
+        { kind: 'call', dst: 't3', fn: 'test:fold', args: [t('t2'), t('t1'), t('step')] },
+      ], { kind: 'return', value: t('t3') }),
+    ])
+
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(1)
+    expect(tailBlocks[0].argCount).toBe(3)
+
+    const optimized = tailCallOptimize(fn)
+    expect(countCalls(optimized, 'test:fold')).toBe(0)
+    expect(optimized.entry).toBe('__tco_entry')
+  })
+
+  test('4-param tail-recursive function eliminates calls', () => {
+    const fn = mkFn('test:quad', ['a', 'b', 'c', 'd'], [
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'le', a: t('a'), b: c(0) },
+      ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'recurse' }),
+
+      mkBlock('base', [], { kind: 'return', value: t('b') }),
+
+      mkBlock('recurse', [
+        { kind: 'sub', dst: 't1', a: t('a'), b: c(1) },
+        { kind: 'add', dst: 't2', a: t('b'), b: t('c') },
+        { kind: 'call', dst: 't3', fn: 'test:quad', args: [t('t1'), t('t2'), t('c'), t('d')] },
+      ], { kind: 'return', value: t('t3') }),
+    ])
+
+    const optimized = tailCallOptimize(fn)
+    expect(countCalls(optimized, 'test:quad')).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Mixed returns: some tail calls, some not
+// ---------------------------------------------------------------------------
+
+describe('tailCallOptimize — mixed tail/non-tail blocks', () => {
+  test('only tail-call blocks are rewritten, others pass through', () => {
+    // Function with two recursive blocks, only one is a proper tail call
+    const fn = mkFn('test:mixed', ['n', 'acc'], [
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(0) },
+      ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'check' }),
+
+      mkBlock('base', [], { kind: 'return', value: t('acc') }),
+
+      mkBlock('check', [
+        { kind: 'cmp', dst: 't1', op: 'eq', a: t('n'), b: c(1) },
+      ], { kind: 'branch', cond: t('t1'), then: 'non_tail', else: 'tail' }),
+
+      // Non-tail: result is used in computation
+      mkBlock('non_tail', [
+        { kind: 'sub', dst: 't2', a: t('n'), b: c(1) },
+        { kind: 'call', dst: 't3', fn: 'test:mixed', args: [t('t2'), t('acc')] },
+        { kind: 'add', dst: 't4', a: t('t3'), b: c(1) }, // post-process!
+      ], { kind: 'return', value: t('t4') }),
+
+      // Proper tail call
+      mkBlock('tail', [
+        { kind: 'sub', dst: 't5', a: t('n'), b: c(1) },
+        { kind: 'add', dst: 't6', a: t('acc'), b: t('n') },
+        { kind: 'call', dst: 't7', fn: 'test:mixed', args: [t('t5'), t('t6')] },
+      ], { kind: 'return', value: t('t7') }),
+    ])
+
+    const tailBlocks = findTailCallBlocks(fn)
+    // Only 'tail' block is a proper tail call
+    expect(tailBlocks.some(b => b.blockId === 'tail')).toBe(true)
+    expect(tailBlocks.some(b => b.blockId === 'non_tail')).toBe(false)
+
+    const optimized = tailCallOptimize(fn)
+    // The self-call in 'tail' block is eliminated; non_tail still has its call
+    // After optimization the tail block becomes a jump
+    const tailBlockAfter = optimized.blocks.find(b => b.id === 'tail')
+    expect(tailBlockAfter?.term.kind).toBe('jump')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Edge case: block without call instruction
+// ---------------------------------------------------------------------------
+
+describe('findTailCallBlocks — edge cases', () => {
+  test('block ending in return with no call before it', () => {
+    const fn = mkFn('test:nocall', ['x'], [
+      mkBlock('entry', [
+        { kind: 'add', dst: 't0', a: t('x'), b: c(1) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+  })
+
+  test('block with non-return terminator (jump) is not a tail block', () => {
+    const fn = mkFn('test:jump_term', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:jump_term', args: [t('x')] },
+      ], { kind: 'jump', target: 'exit' }),
+      mkBlock('exit', [], { kind: 'return', value: t('x') }),
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+  })
+
+  test('return with null value is not a tail call', () => {
+    const fn = mkFn('test:void_ret', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:void_ret', args: [t('x')] },
+      ], { kind: 'return', value: null }),
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+  })
+
+  test('return with const value (not temp) is not a tail call', () => {
+    const fn = mkFn('test:const_ret', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:const_ret', args: [t('x')] },
+      ], { kind: 'return', value: c(0) }),
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+  })
+
+  test('tail call where dst is null is not detected', () => {
+    const fn = mkFn('test:null_dst', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: null as unknown as string, fn: 'test:null_dst', args: [t('x')] },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+  })
+
+  test('mismatched call dst and return value temp', () => {
+    const fn = mkFn('test:mismatch', ['x'], [
+      mkBlock('entry', [
+        { kind: 'call', dst: 't0', fn: 'test:mismatch', args: [t('x')] },
+      ], { kind: 'return', value: t('t1') }), // t1 != t0
+    ])
+    const tailBlocks = findTailCallBlocks(fn)
+    expect(tailBlocks).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Loop param substitution verification
+// ---------------------------------------------------------------------------
+
+describe('tailCallOptimize — substitution', () => {
+  test('loop param temps are created for each param', () => {
+    const fn = mkFn('test:sub', ['a', 'b'], [
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'le', a: t('a'), b: c(0) },
+      ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'rec' }),
+      mkBlock('base', [], { kind: 'return', value: t('b') }),
+      mkBlock('rec', [
+        { kind: 'sub', dst: 't1', a: t('a'), b: c(1) },
+        { kind: 'add', dst: 't2', a: t('b'), b: t('a') },
+        { kind: 'call', dst: 't3', fn: 'test:sub', args: [t('t1'), t('t2')] },
+      ], { kind: 'return', value: t('t3') }),
+    ])
+
+    const optimized = tailCallOptimize(fn)
+    // Should have __tco_entry with copy instrs for each param
+    const newEntry = optimized.blocks.find(b => b.id === '__tco_entry')
+    expect(newEntry).toBeDefined()
+    expect(newEntry!.instrs.length).toBe(2) // 2 params → 2 copy instrs
+    expect(newEntry!.instrs[0].kind).toBe('copy')
+    expect(newEntry!.instrs[1].kind).toBe('copy')
+  })
+
+  test('non-tail blocks have params substituted with loop params', () => {
+    const fn = mkFn('test:subst', ['n', 'acc'], [
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(0) },
+      ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'rec' }),
+      mkBlock('base', [], { kind: 'return', value: t('acc') }),
+      mkBlock('rec', [
+        { kind: 'sub', dst: 't1', a: t('n'), b: c(1) },
+        { kind: 'call', dst: 't2', fn: 'test:subst', args: [t('t1'), t('acc')] },
+      ], { kind: 'return', value: t('t2') }),
+    ])
+
+    const optimized = tailCallOptimize(fn)
+    // 'base' block should have its return value substituted to __lp1 (the acc loop param)
+    const baseBlock = optimized.blocks.find(b => b.id === 'base')
+    expect(baseBlock).toBeDefined()
+    const retTerm = baseBlock!.term as Extract<MIRInstr, { kind: 'return' }>
+    expect(retTerm.value?.kind).toBe('temp')
+    expect((retTerm.value as Extract<Operand, { kind: 'temp' }>).name).toBe('__lp1')
+  })
+})