redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/modules.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Phase 5b — Module system tests
+ *
+ * Tests for `module <name>;`, `export fn`, `import <mod>::<sym>;`, and
+ * cross-module function calls with namespace-isolated scoreboards.
+ */
+
+import { compileModules } from '../emit/modules'
+
+function getFile(files: { path: string; content: string }[], substr: string): string | undefined {
+  return files.find(f => f.path.includes(substr))?.content
+}
+
+function getPath(files: { path: string; content: string }[], substr: string): string | undefined {
+  return files.find(f => f.path.includes(substr))?.path
+}
+
+// ---------------------------------------------------------------------------
+// Basic module declaration and export
+// ---------------------------------------------------------------------------
+
+describe('module declaration', () => {
+  test('module <name>; prefixes function paths with module name', () => {
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn add(a: int, b: int): int { return a + b; }
+        `,
+      },
+    ], { namespace: 'ns' })
+
+    // Function should be emitted under math/add path
+    const path = getPath(result.files, 'math/add')
+    expect(path).toBeDefined()
+    expect(path).toMatch(/math\/add\.mcfunction$/)
+  })
+
+  test('non-exported function in module gets no special treatment', () => {
+    const result = compileModules([
+      {
+        name: 'utils',
+        source: `
+          module utils;
+          export fn pub() { say("public"); }
+          fn priv() { say("private"); }
+        `,
+      },
+    ], { namespace: 'ns' })
+
+    expect(getFile(result.files, 'utils/pub')).toBeDefined()
+    expect(getFile(result.files, 'utils/priv')).toBeDefined()
+  })
+
+  test('named module gets per-module scoreboard objective in load file', () => {
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn add(a: int, b: int): int { return a + b; }
+        `,
+      },
+    ], { namespace: 'mypack' })
+
+    // load.mcfunction for named module lives under math/_load.mcfunction
+    const loadContent = getFile(result.files, 'math/_load')
+    expect(loadContent).toBeDefined()
+    // It should create the module-namespaced objective
+    expect(loadContent).toContain('scoreboard objectives add __mypack_math dummy')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Import and cross-module calls
+// ---------------------------------------------------------------------------
+
+describe('cross-module imports', () => {
+  test('import math::add resolves to math/add function path', () => {
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn add(a: int, b: int): int { return a + b; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import math::add;
+          fn main() { let x: int = add(1, 2); }
+        `,
+      },
+    ], { namespace: 'ns' })
+
+    const mainContent = getFile(result.files, '/main.mcfunction')
+    expect(mainContent).toBeDefined()
+    // Cross-module call must use the qualified path
+    expect(mainContent).toContain('function ns:math/add')
+  })
+
+  test('import math::* imports all exports from math', () => {
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn sin(x: int): int { return x; }
+          export fn cos(x: int): int { return x; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import math::*;
+          fn main() {
+            let a: int = sin(1);
+            let b: int = cos(2);
+          }
+        `,
+      },
+    ], { namespace: 'ns' })
+
+    const mainContent = getFile(result.files, '/main.mcfunction')
+    expect(mainContent).toBeDefined()
+    expect(mainContent).toContain('function ns:math/sin')
+    expect(mainContent).toContain('function ns:math/cos')
+  })
+
+  test('multiple modules importing each other', () => {
+    const result = compileModules([
+      {
+        name: 'vec',
+        source: `
+          module vec;
+          export fn dot(a: int, b: int): int { return a * b; }
+        `,
+      },
+      {
+        name: 'physics',
+        source: `
+          module physics;
+          import vec::dot;
+          export fn energy(v: int): int { return dot(v, v); }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import physics::energy;
+          @tick fn tick() { let e: int = energy(5); }
+        `,
+      },
+    ], { namespace: 'game' })
+
+    // physics/energy should call vec/dot
+    const physicsContent = getFile(result.files, 'physics/energy')
+    expect(physicsContent).toBeDefined()
+    expect(physicsContent).toContain('function game:vec/dot')
+
+    // main tick should call physics/energy
+    const tickContent = getFile(result.files, '/tick.mcfunction')
+    expect(tickContent).toBeDefined()
+    expect(tickContent).toContain('function game:physics/energy')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// DCE across modules
+// ---------------------------------------------------------------------------
+
+describe('cross-module DCE', () => {
+  test('exported function not imported anywhere is DCE-eligible (library fn)', () => {
+    // export fn unused in `math` — never imported in `main`
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn used(x: int): int { return x; }
+          export fn unused(x: int): int { return x + 1; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import math::used;
+          @tick fn tick() { let x: int = used(3); }
+        `,
+      },
+    ], { namespace: 'ns' })
+
+    // `math/used` must be present
+    expect(getFile(result.files, 'math/used')).toBeDefined()
+    // `math/unused` should be DCE'd (it's marked as library fn)
+    // (library fns are stripped if not reachable from any entry point)
+    expect(getFile(result.files, 'math/unused')).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Circular import detection
+// ---------------------------------------------------------------------------
+
+describe('circular import detection', () => {
+  test('direct circular import throws LoweringError', () => {
+    expect(() => compileModules([
+      {
+        name: 'a',
+        source: `
+          module a;
+          import b::foo;
+          export fn bar() { foo(); }
+        `,
+      },
+      {
+        name: 'b',
+        source: `
+          module b;
+          import a::bar;
+          export fn foo() { bar(); }
+        `,
+      },
+    ], { namespace: 'ns' })).toThrow(/Circular import/)
+  })
+
+  test('transitive circular import throws LoweringError', () => {
+    expect(() => compileModules([
+      {
+        name: 'a',
+        source: `
+          module a;
+          import c::baz;
+          export fn foo() { baz(); }
+        `,
+      },
+      {
+        name: 'b',
+        source: `
+          module b;
+          import a::foo;
+          export fn bar() { foo(); }
+        `,
+      },
+      {
+        name: 'c',
+        source: `
+          module c;
+          import b::bar;
+          export fn baz() { bar(); }
+        `,
+      },
+    ], { namespace: 'ns' })).toThrow(/Circular import/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error cases
+// ---------------------------------------------------------------------------
+
+describe('module error cases', () => {
+  test('importing non-existent module throws', () => {
+    expect(() => compileModules([
+      {
+        name: 'main',
+        source: `
+          import nonexistent::foo;
+          fn main() { foo(); }
+        `,
+      },
+    ], { namespace: 'ns' })).toThrow(/not found/)
+  })
+
+  test('importing non-exported symbol throws', () => {
+    expect(() => compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          fn private_fn() { }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import math::private_fn;
+          fn main() { private_fn(); }
+        `,
+      },
+    ], { namespace: 'ns' })).toThrow(/does not export/)
+  })
+
+  test('module name mismatch throws', () => {
+    expect(() => compileModules([
+      {
+        name: 'wrong_name',
+        source: `
+          module math;
+          export fn add(a: int, b: int): int { return a + b; }
+        `,
+      },
+    ], { namespace: 'ns' })).toThrow(/registered as/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Namespace isolation
+// ---------------------------------------------------------------------------
+
+describe('namespace isolation', () => {
+  test('each named module has its own scoreboard objective', () => {
+    const result = compileModules([
+      {
+        name: 'modA',
+        source: `
+          module modA;
+          export fn hello() { say("hello"); }
+        `,
+      },
+      {
+        name: 'modB',
+        source: `
+          module modB;
+          export fn world() { say("world"); }
+        `,
+      },
+    ], { namespace: 'myns' })
+
+    const loadA = getFile(result.files, 'modA/_load')
+    const loadB = getFile(result.files, 'modB/_load')
+
+    expect(loadA).toBeDefined()
+    expect(loadA).toContain('__myns_modA')
+
+    expect(loadB).toBeDefined()
+    expect(loadB).toContain('__myns_modB')
+  })
+
+  test('load.json includes all module load functions', () => {
+    const result = compileModules([
+      {
+        name: 'a',
+        source: `
+          module a;
+          export fn f() { }
+        `,
+      },
+      {
+        name: 'b',
+        source: `
+          module b;
+          export fn g() { }
+        `,
+      },
+    ], { namespace: 'ns' })
+
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const tag = JSON.parse(loadJson!)
+    expect(tag.values).toContain('ns:a/_load')
+    expect(tag.values).toContain('ns:b/_load')
+  })
+})

package/src/__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/src/__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' })
+  })
+})

package/src/__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')
+  })
+})