redscript-mc 1.2.30 → 2.0.0

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

@@ -0,0 +1,145 @@
+import { constantFold } from '../../optimizer/constant_fold'
+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('constant folding', () => {
+  test('folds add(const, const)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'add', dst: 't0', a: c(3), b: c(4) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 })
+  })
+
+  test('folds sub(const, const)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'sub', dst: 't0', a: c(10), b: c(3) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 })
+  })
+
+  test('folds mul(const, const)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'mul', dst: 't0', a: c(3), b: c(5) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 15 })
+  })
+
+  test('folds div(const, const) with truncation', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'div', dst: 't0', a: c(7), b: c(2) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 3 })
+  })
+
+  test('does not fold div by zero', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'div', dst: 't0', a: c(7), b: c(0) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0].kind).toBe('div')
+  })
+
+  test('folds mod(const, const)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'mod', dst: 't0', a: c(7), b: c(3) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 })
+  })
+
+  test('folds neg(const)', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'neg', dst: 't0', src: c(5) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: -5 })
+  })
+
+  test('folds not(0) → 1', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'not', dst: 't0', src: c(0) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 })
+  })
+
+  test('folds cmp(lt, 3, 4) → 1', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'lt', a: c(3), b: c(4) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 })
+  })
+
+  test('folds cmp(eq, 5, 5) → 1', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'cmp', dst: 't0', op: 'eq', a: c(5), b: c(5) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 })
+  })
+
+  test('folds and(1, 0) → 0', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'and', dst: 't0', a: c(1), b: c(0) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 0 })
+  })
+
+  test('folds or(0, 1) → 1', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'or', dst: 't0', a: c(0), b: c(1) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 })
+  })
+
+  test('does not fold when operand is temp', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'add', dst: 't0', a: t('a'), b: c(4) },
+      ], { kind: 'return', value: t('t0') }),
+    ])
+    const result = constantFold(fn)
+    expect(result.blocks[0].instrs[0].kind).toBe('add')
+  })
+})

package/src2/__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/src2/__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/src2/__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/src2/emit/compile.ts

@@ -0,0 +1,99 @@
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → HIR → MIR → optimize → LIR → emit
+ */
+
+import { Lexer } from '../../src/lexer'
+import { Parser } from '../../src/parser'
+import { preprocessSourceWithMetadata } from '../../src/compile'
+import { lowerToHIR } from '../hir/lower'
+import { lowerToMIR } from '../mir/lower'
+import { optimizeModule } from '../optimizer/pipeline'
+import { lowerToLIR } from '../lir/lower'
+import { emit, type DatapackFile } from './index'
+
+export interface CompileOptions {
+  namespace?: string
+  filePath?: string
+  /** v1 compat: inline library sources (treated as `module library;` imports) */
+  librarySources?: string[]
+}
+
+export interface CompileResult {
+  files: DatapackFile[]
+  warnings: string[]
+  /** Always true — v1 compat shim (compile() throws on error) */
+  readonly success: true
+}
+
+export function compile(source: string, options: CompileOptions = {}): CompileResult {
+  const { namespace = 'redscript', filePath } = options
+  const warnings: string[] = []
+
+  // Preprocess: resolve import directives, merge imported sources
+  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+  const processedSource = preprocessed.source
+
+  // Stage 1: Lex + Parse → AST
+  const lexer = new Lexer(processedSource)
+  const tokens = lexer.tokenize()
+  const parser = new Parser(tokens, processedSource, filePath)
+  const ast = parser.parse(namespace)
+
+  // Merge library imports (files with `module library;`) into AST
+  for (const li of preprocessed.libraryImports ?? []) {
+    const libPreprocessed = preprocessSourceWithMetadata(li.source, { filePath: li.filePath })
+    const libTokens = new Lexer(libPreprocessed.source, li.filePath).tokenize()
+    const libAst = new Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace)
+    for (const fn of libAst.declarations) fn.isLibraryFn = true
+    ast.declarations.push(...libAst.declarations)
+    ast.structs.push(...libAst.structs)
+    ast.implBlocks.push(...libAst.implBlocks)
+    ast.enums.push(...libAst.enums)
+    ast.consts.push(...libAst.consts)
+    ast.globals.push(...libAst.globals)
+  }
+
+  // Merge librarySources (v1 compat: inline library strings) before HIR
+  if (options.librarySources) {
+    for (const libSrc of options.librarySources) {
+      const libTokens = new Lexer(libSrc).tokenize()
+      const libAst = new Parser(libTokens, libSrc).parse(namespace)
+      for (const fn of libAst.declarations) fn.isLibraryFn = true
+      ast.declarations.push(...libAst.declarations)
+      ast.structs.push(...libAst.structs)
+      ast.implBlocks.push(...libAst.implBlocks)
+      ast.enums.push(...libAst.enums)
+      ast.consts.push(...libAst.consts)
+      ast.globals.push(...libAst.globals)
+    }
+  }
+
+  // Stage 2: AST → HIR
+  const hir = lowerToHIR(ast)
+
+  // Extract @tick and @load functions from HIR (before decorator info is lost)
+  const tickFunctions: string[] = []
+  const loadFunctions: string[] = []
+  for (const fn of hir.functions) {
+    for (const dec of fn.decorators) {
+      if (dec.name === 'tick') tickFunctions.push(fn.name)
+      if (dec.name === 'load') loadFunctions.push(fn.name)
+    }
+  }
+
+  // Stage 3: HIR → MIR
+  const mir = lowerToMIR(hir)
+
+  // Stage 4: MIR optimization
+  const mirOpt = optimizeModule(mir)
+
+  // Stage 5: MIR → LIR
+  const lir = lowerToLIR(mirOpt)
+
+  // Stage 7: LIR → .mcfunction
+  const files = emit(lir, { namespace, tickFunctions, loadFunctions })
+
+  return { files, warnings, success: true as const }
+}