redscript-mc 1.2.30 → 2.0.0

package/src2/__tests__/mir/control-flow.test.ts

@@ -0,0 +1,242 @@
+import { Lexer } from '../../../src/lexer'
+import { Parser } from '../../../src/parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import type { MIRModule, MIRBlock, MIRInstr, MIRFunction } from '../../mir/types'
+
+function compile(source: string): MIRModule {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  const hir = lowerToHIR(ast)
+  return lowerToMIR(hir)
+}
+
+function getFn(mod: MIRModule, name?: string): MIRFunction {
+  if (name) return mod.functions.find(f => f.name === name)!
+  return mod.functions[0]
+}
+
+function getBlock(fn: MIRFunction, id: string): MIRBlock | undefined {
+  return fn.blocks.find(b => b.id === id)
+}
+
+describe('MIR lowering — if/else → branch CFG', () => {
+  test('if without else creates branch to then + merge', () => {
+    const mod = compile('fn f(x: int): int { if (x > 0) { return x; } return 0; }')
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    // Entry block should end with a branch
+    const entry = getBlock(fn, fn.entry)!
+    expect(entry.term.kind).toBe('branch')
+
+    const branch = entry.term as Extract<MIRInstr, { kind: 'branch' }>
+    // Both targets should exist
+    expect(fn.blocks.some(b => b.id === branch.then)).toBe(true)
+    expect(fn.blocks.some(b => b.id === branch.else)).toBe(true)
+  })
+
+  test('if/else creates branch to then + else + merge', () => {
+    const mod = compile(`
+      fn f(x: int): int {
+        if (x > 0) { return 1; }
+        else { return -1; }
+      }
+    `)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    const entry = getBlock(fn, fn.entry)!
+    expect(entry.term.kind).toBe('branch')
+
+    const branch = entry.term as Extract<MIRInstr, { kind: 'branch' }>
+    const thenBlock = getBlock(fn, branch.then)!
+    const elseBlock = getBlock(fn, branch.else)!
+
+    // Both branches should have return terminators
+    expect(thenBlock.term.kind).toBe('return')
+    expect(elseBlock.term.kind).toBe('return')
+  })
+
+  test('nested if/else produces correct block structure', () => {
+    const mod = compile(`
+      fn f(x: int): int {
+        if (x > 0) {
+          if (x > 10) { return 2; }
+          return 1;
+        }
+        return 0;
+      }
+    `)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    // Should have multiple blocks due to nesting
+    expect(fn.blocks.length).toBeGreaterThanOrEqual(4)
+  })
+})
+
+describe('MIR lowering — while → loop CFG', () => {
+  test('while loop creates header + body + exit blocks', () => {
+    const mod = compile(`
+      fn f(x: int): int {
+        let sum: int = 0;
+        while (x > 0) {
+          sum = sum + x;
+          x = x - 1;
+        }
+        return sum;
+      }
+    `)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    // Find loop header block (has branch terminator based on condition)
+    const headerBlock = fn.blocks.find(b =>
+      b.id.startsWith('loop_header') && b.term.kind === 'branch'
+    )
+    expect(headerBlock).toBeDefined()
+
+    // Find loop body block
+    const bodyBlock = fn.blocks.find(b => b.id.startsWith('loop_body'))
+    expect(bodyBlock).toBeDefined()
+
+    // Find loop exit block
+    const exitBlock = fn.blocks.find(b => b.id.startsWith('loop_exit'))
+    expect(exitBlock).toBeDefined()
+
+    // Header should branch to body (then) and exit (else)
+    const branch = headerBlock!.term as Extract<MIRInstr, { kind: 'branch' }>
+    expect(branch.then).toBe(bodyBlock!.id)
+    expect(branch.else).toBe(exitBlock!.id)
+  })
+
+  test('break jumps to loop exit', () => {
+    const mod = compile(`
+      fn f(x: int): void {
+        while (x > 0) {
+          if (x == 5) { break; }
+          x = x - 1;
+        }
+      }
+    `)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    const exitBlock = fn.blocks.find(b => b.id.startsWith('loop_exit'))
+    expect(exitBlock).toBeDefined()
+
+    // Some block should jump directly to the exit (the break)
+    const breakBlock = fn.blocks.find(b =>
+      b.term.kind === 'jump' && (b.term as any).target === exitBlock!.id
+      && !b.id.startsWith('loop_header') && !b.id.startsWith('loop_exit')
+      && !b.id.startsWith('entry')
+    )
+    expect(breakBlock).toBeDefined()
+  })
+
+  test('continue jumps to loop header', () => {
+    const mod = compile(`
+      fn f(x: int): void {
+        while (x > 0) {
+          x = x - 1;
+          if (x == 3) { continue; }
+        }
+      }
+    `)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header'))
+    expect(headerBlock).toBeDefined()
+
+    // Some block should jump to header (the continue)
+    const continueBlock = fn.blocks.find(b =>
+      b.term.kind === 'jump' && (b.term as any).target === headerBlock!.id
+      && !b.id.startsWith('loop_body') && !b.id.startsWith('entry')
+    )
+    expect(continueBlock).toBeDefined()
+  })
+})
+
+describe('MIR lowering — short-circuit operators', () => {
+  test('&& produces branch (short-circuit)', () => {
+    const mod = compile('fn f(a: bool, b: bool): bool { return a && b; }')
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    // Should have and_right, and_false, and_merge blocks
+    expect(fn.blocks.some(b => b.id.startsWith('and_right'))).toBe(true)
+    expect(fn.blocks.some(b => b.id.startsWith('and_false'))).toBe(true)
+    expect(fn.blocks.some(b => b.id.startsWith('and_merge'))).toBe(true)
+  })
+
+  test('|| produces branch (short-circuit)', () => {
+    const mod = compile('fn f(a: bool, b: bool): bool { return a || b; }')
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    expect(fn.blocks.some(b => b.id.startsWith('or_true'))).toBe(true)
+    expect(fn.blocks.some(b => b.id.startsWith('or_right'))).toBe(true)
+    expect(fn.blocks.some(b => b.id.startsWith('or_merge'))).toBe(true)
+  })
+})
+
+describe('MIR lowering — return', () => {
+  test('void return', () => {
+    const mod = compile('fn f(): void { return; }')
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    const entry = getBlock(fn, fn.entry)!
+    expect(entry.term.kind).toBe('return')
+    expect((entry.term as any).value).toBeNull()
+  })
+
+  test('value return', () => {
+    const mod = compile('fn f(): int { return 42; }')
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    const entry = getBlock(fn, fn.entry)!
+    expect(entry.term.kind).toBe('return')
+    expect((entry.term as any).value).toEqual({ kind: 'const', value: 42 })
+  })
+
+  test('early return creates dead block for subsequent code', () => {
+    const mod = compile(`
+      fn f(x: int): int {
+        return x;
+        let y: int = 0;
+      }
+    `)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod)
+    const entry = getBlock(fn, fn.entry)!
+    expect(entry.term.kind).toBe('return')
+  })
+})
+
+describe('MIR lowering — all blocks reachable and well-formed', () => {
+  test('complex function verifies clean', () => {
+    const mod = compile(`
+      fn f(n: int): int {
+        let sum: int = 0;
+        let i: int = 0;
+        while (i < n) {
+          if (i % 2 == 0) {
+            sum = sum + i;
+          } else {
+            sum = sum - i;
+          }
+          i = i + 1;
+        }
+        return sum;
+      }
+    `)
+    const errors = verifyMIR(mod)
+    expect(errors).toEqual([])
+  })
+})

package/src2/__tests__/mir/verify.test.ts

@@ -0,0 +1,254 @@
+import { verifyMIR } from '../../mir/verify'
+import type { MIRModule, MIRBlock, MIRFunction } from '../../mir/types'
+
+function makeModule(functions: MIRFunction[]): MIRModule {
+  return { functions, namespace: 'test', objective: '__test' }
+}
+
+function makeBlock(id: string, instrs: any[], term: any, preds: string[] = []): MIRBlock {
+  return { id, instrs, term, preds }
+}
+
+describe('MIR verifier — terminator checks', () => {
+  test('rejects block without proper terminator', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock('entry', [], { kind: 'const', dst: 't0', value: 42 }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('does not end with a terminator')
+  })
+
+  test('rejects terminator in non-terminal position', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock(
+          'entry',
+          [{ kind: 'jump', target: 'entry' }], // terminator in instrs
+          { kind: 'return', value: null },
+        ),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('terminator')
+    expect(errors[0].message).toContain('non-terminal position')
+  })
+
+  test('accepts valid terminator (return)', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [],
+      blocks: [
+        makeBlock('entry', [], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+
+  test('accepts valid terminator (jump)', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [],
+      blocks: [
+        makeBlock('entry', [], { kind: 'jump', target: 'b1' }),
+        makeBlock('b1', [], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+})
+
+describe('MIR verifier — target existence', () => {
+  test('rejects jump to non-existent block', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock('entry', [], { kind: 'jump', target: 'nonexistent' }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('non-existent target')
+  })
+
+  test('rejects branch to non-existent block', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock('entry', [
+          { kind: 'const', dst: 't0', value: 1 },
+        ], { kind: 'branch', cond: { kind: 'temp', name: 't0' }, then: 'yes', else: 'no' }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.length).toBe(2) // both targets missing
+    expect(errors[0].message).toContain('non-existent target')
+  })
+})
+
+describe('MIR verifier — reachability', () => {
+  test('rejects unreachable block', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock('entry', [], { kind: 'return', value: null }),
+        makeBlock('orphan', [], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.length).toBe(1)
+    expect(errors[0].message).toContain('unreachable')
+    expect(errors[0].block).toBe('orphan')
+  })
+
+  test('accepts all blocks reachable via jumps', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [],
+      blocks: [
+        makeBlock('entry', [], { kind: 'jump', target: 'b1' }),
+        makeBlock('b1', [], { kind: 'jump', target: 'b2' }),
+        makeBlock('b2', [], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+
+  test('accepts blocks reachable via branch', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [],
+      blocks: [
+        makeBlock('entry', [
+          { kind: 'const', dst: 't0', value: 1 },
+        ], { kind: 'branch', cond: { kind: 'temp', name: 't0' }, then: 'yes', else: 'no' }),
+        makeBlock('yes', [], { kind: 'return', value: null }),
+        makeBlock('no', [], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+})
+
+describe('MIR verifier — use-before-def', () => {
+  test('rejects use of undefined temp', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock('entry', [
+          { kind: 'copy', dst: 't0', src: { kind: 'temp', name: 'undefined_temp' } },
+        ], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('undefined_temp')
+    expect(errors[0].message).toContain('never defined')
+  })
+
+  test('accepts temps defined as params', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [{ name: 't0', isMacroParam: false }],
+      blocks: [
+        makeBlock('entry', [], { kind: 'return', value: { kind: 'temp', name: 't0' } }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+
+  test('accepts temps defined in instructions', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [],
+      blocks: [
+        makeBlock('entry', [
+          { kind: 'const', dst: 't0', value: 42 },
+          { kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } },
+        ], { kind: 'return', value: { kind: 'temp', name: 't1' } }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+
+  test('const operands do not require definition', () => {
+    const fn: MIRFunction = {
+      name: 'good',
+      params: [],
+      blocks: [
+        makeBlock('entry', [
+          { kind: 'const', dst: 't0', value: 5 },
+          { kind: 'add', dst: 't1', a: { kind: 'temp', name: 't0' }, b: { kind: 'const', value: 3 } },
+        ], { kind: 'return', value: { kind: 'temp', name: 't1' } }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    expect(verifyMIR(makeModule([fn]))).toEqual([])
+  })
+})
+
+describe('MIR verifier — entry block', () => {
+  test('rejects missing entry block', () => {
+    const fn: MIRFunction = {
+      name: 'bad',
+      params: [],
+      blocks: [
+        makeBlock('not_entry', [], { kind: 'return', value: null }),
+      ],
+      entry: 'entry',
+      isMacro: false,
+    }
+
+    const errors = verifyMIR(makeModule([fn]))
+    expect(errors.some(e => e.message.includes('entry block'))).toBe(true)
+  })
+})

package/src2/__tests__/optimizer/block_merge.test.ts

@@ -0,0 +1,84 @@
+import { blockMerge } from '../../optimizer/block_merge'
+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('block merging', () => {
+  test('merges single-pred successor into predecessor', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 't0', value: 1 },
+      ], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [
+        { kind: 'const', dst: 't1', value: 2 },
+      ], { kind: 'return', value: t('t1') }, ['entry']),
+    ])
+    const result = blockMerge(fn)
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].id).toBe('entry')
+    expect(result.blocks[0].instrs).toHaveLength(2)
+    expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('t1') })
+  })
+
+  test('does not merge when successor has multiple preds', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'branch', cond: t('c'), then: 'b1', else: 'b2' }),
+      mkBlock('b1', [], { kind: 'jump', target: 'merge' }, ['entry']),
+      mkBlock('b2', [], { kind: 'jump', target: 'merge' }, ['entry']),
+      mkBlock('merge', [], { kind: 'return', value: null }, ['b1', 'b2']),
+    ])
+    const result = blockMerge(fn)
+    // merge has 2 preds → no merging of merge block
+    expect(result.blocks.length).toBeGreaterThanOrEqual(3)
+    expect(result.blocks.some(b => b.id === 'merge')).toBe(true)
+  })
+
+  test('does not merge entry block into predecessor', () => {
+    // Entry block should never be merged away
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+    ])
+    const result = blockMerge(fn)
+    // b1 has single pred → merged into entry
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].id).toBe('entry')
+  })
+
+  test('chains merges: A→B→C all single-pred', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'const', dst: 't0', value: 1 },
+      ], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [
+        { kind: 'const', dst: 't1', value: 2 },
+      ], { kind: 'jump', target: 'b2' }, ['entry']),
+      mkBlock('b2', [
+        { kind: 'const', dst: 't2', value: 3 },
+      ], { kind: 'return', value: t('t2') }, ['b1']),
+    ])
+    const result = blockMerge(fn)
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].instrs).toHaveLength(3)
+  })
+
+  test('recomputes preds after merge', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [], { kind: 'jump', target: 'b2' }, ['entry']),
+      mkBlock('b2', [], { kind: 'return', value: null }, ['b1']),
+    ])
+    const result = blockMerge(fn)
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].preds).toEqual([])
+  })
+})

package/src2/__tests__/optimizer/branch_simplify.test.ts

@@ -0,0 +1,64 @@
+import { branchSimplify } from '../../optimizer/branch_simplify'
+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, 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('branch simplification', () => {
+  test('branch(1, then, else) → jump(then)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'branch', cond: c(1), then: 'b1', else: 'b2' }),
+      mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+      mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+    ])
+    const result = branchSimplify(fn)
+    expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' })
+  })
+
+  test('branch(0, then, else) → jump(else)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'branch', cond: c(0), then: 'b1', else: 'b2' }),
+      mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+      mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+    ])
+    const result = branchSimplify(fn)
+    expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b2' })
+  })
+
+  test('nonzero const (42) → jump(then)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'branch', cond: c(42), then: 'b1', else: 'b2' }),
+      mkBlock('b1', [], { kind: 'return', value: null }),
+      mkBlock('b2', [], { kind: 'return', value: null }),
+    ])
+    const result = branchSimplify(fn)
+    expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' })
+  })
+
+  test('does not simplify branch with temp cond', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'branch', cond: t('flag'), then: 'b1', else: 'b2' }),
+      mkBlock('b1', [], { kind: 'return', value: null }),
+      mkBlock('b2', [], { kind: 'return', value: null }),
+    ])
+    const result = branchSimplify(fn)
+    expect(result.blocks[0].term.kind).toBe('branch')
+  })
+
+  test('does not touch jump terminators', () => {
+    const fn = mkFn([
+      mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [], { kind: 'return', value: null }),
+    ])
+    const result = branchSimplify(fn)
+    expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' })
+  })
+})