redscript-mc 2.0.0 → 2.1.0

package/src/__tests__/mc-version.test.ts

@@ -0,0 +1,178 @@
+/**
+ * MC Version Tests — Phase 5a
+ *
+ * Verifies:
+ *  - parseMcVersion() parses version strings correctly
+ *  - compareMcVersion() returns the right ordering
+ *  - Codegen emits macro syntax ($ prefix, `with storage`) for >= 1.20.2
+ *  - Codegen emits compat syntax for < 1.20.2
+ */
+
+import { compile } from '../index'
+import { McVersion, parseMcVersion, compareMcVersion, DEFAULT_MC_VERSION } from '../types/mc-version'
+
+// ---------------------------------------------------------------------------
+// parseMcVersion
+// ---------------------------------------------------------------------------
+
+describe('parseMcVersion', () => {
+  it('parses "1.21" correctly', () => {
+    expect(parseMcVersion('1.21')).toBe(McVersion.v1_21)
+  })
+
+  it('parses "1.20.2" correctly', () => {
+    expect(parseMcVersion('1.20.2')).toBe(McVersion.v1_20_2)
+  })
+
+  it('parses "1.20" correctly', () => {
+    expect(parseMcVersion('1.20')).toBe(McVersion.v1_20)
+  })
+
+  it('parses "1.19" correctly', () => {
+    expect(parseMcVersion('1.19')).toBe(McVersion.v1_19)
+  })
+
+  it('parses "1.21.4" correctly', () => {
+    expect(parseMcVersion('1.21.4')).toBe(McVersion.v1_21_4)
+  })
+
+  it('throws on invalid format', () => {
+    expect(() => parseMcVersion('1')).toThrow()
+    expect(() => parseMcVersion('abc')).toThrow()
+    expect(() => parseMcVersion('2.0')).toThrow()
+    expect(() => parseMcVersion('1.20.2.1')).toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// compareMcVersion
+// ---------------------------------------------------------------------------
+
+describe('compareMcVersion', () => {
+  it('returns 0 for equal versions', () => {
+    expect(compareMcVersion(McVersion.v1_21, McVersion.v1_21)).toBe(0)
+  })
+
+  it('returns negative when a < b', () => {
+    expect(compareMcVersion(McVersion.v1_20, McVersion.v1_21)).toBeLessThan(0)
+    expect(compareMcVersion(McVersion.v1_20_2, McVersion.v1_21)).toBeLessThan(0)
+    expect(compareMcVersion(McVersion.v1_19, McVersion.v1_20_2)).toBeLessThan(0)
+  })
+
+  it('returns positive when a > b', () => {
+    expect(compareMcVersion(McVersion.v1_21, McVersion.v1_20)).toBeGreaterThan(0)
+    expect(compareMcVersion(McVersion.v1_21_4, McVersion.v1_21)).toBeGreaterThan(0)
+  })
+
+  it('1.20.2 >= 1.20.2 boundary', () => {
+    expect(McVersion.v1_20_2 >= McVersion.v1_20_2).toBe(true)
+    expect(McVersion.v1_20 >= McVersion.v1_20_2).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Default version
+// ---------------------------------------------------------------------------
+
+describe('DEFAULT_MC_VERSION', () => {
+  it('is 1.21', () => {
+    expect(DEFAULT_MC_VERSION).toBe(McVersion.v1_21)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Codegen — macro syntax (>= 1.20.2)
+// ---------------------------------------------------------------------------
+
+function getMcFunction(files: ReturnType<typeof compile>['files'], fnSuffix: string): string {
+  const mcPath = `data/test/function/${fnSuffix}.mcfunction`
+  const file = files.find(f => f.path === mcPath)
+  if (!file) {
+    const paths = files.map(f => f.path).join(', ')
+    throw new Error(`Missing mcfunction: ${mcPath}\nAvailable: ${paths}`)
+  }
+  return file.content
+}
+
+const macroSource = `
+fn spawn_zombie(x: int, y: int, z: int) {
+  summon("minecraft:zombie", x, y, z);
+}
+`
+
+describe('codegen — macro syntax (>= 1.20.2)', () => {
+  it('emits $ prefix for macro lines on 1.21', () => {
+    const result = compile(macroSource, { namespace: 'test', mcVersion: McVersion.v1_21 })
+    const fn = getMcFunction(result.files, 'spawn_zombie')
+    expect(fn).toContain('$summon')
+  })
+
+  it('emits `function ... with storage` call for macro on 1.21', () => {
+    const callerSource = `
+fn spawn_zombie(x: int, y: int, z: int) {
+  summon("minecraft:zombie", x, y, z);
+}
+fn main() {
+  spawn_zombie(1, 2, 3);
+}
+`
+    const result = compile(callerSource, { namespace: 'test', mcVersion: McVersion.v1_21 })
+    const fn = getMcFunction(result.files, 'main')
+    expect(fn).toContain('with storage')
+  })
+
+  it('emits $ prefix for macro lines on 1.20.2', () => {
+    const result = compile(macroSource, { namespace: 'test', mcVersion: McVersion.v1_20_2 })
+    const fn = getMcFunction(result.files, 'spawn_zombie')
+    expect(fn).toContain('$summon')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Codegen — compat syntax (< 1.20.2)
+// ---------------------------------------------------------------------------
+
+describe('codegen — compat syntax (< 1.20.2)', () => {
+  it('does NOT emit $ prefix for macro lines on 1.20 (< 1.20.2)', () => {
+    const result = compile(macroSource, { namespace: 'test', mcVersion: McVersion.v1_20 })
+    const fn = getMcFunction(result.files, 'spawn_zombie')
+    // Should not start a line with $summon
+    const lines = fn.split('\n')
+    expect(lines.every(l => !l.startsWith('$summon'))).toBe(true)
+  })
+
+  it('does NOT emit $ prefix for macro lines on 1.19', () => {
+    const result = compile(macroSource, { namespace: 'test', mcVersion: McVersion.v1_19 })
+    const fn = getMcFunction(result.files, 'spawn_zombie')
+    const lines = fn.split('\n')
+    expect(lines.every(l => !l.startsWith('$'))).toBe(true)
+  })
+
+  it('emits plain `function` call (no `with storage`) on 1.19', () => {
+    const callerSource = `
+fn spawn_zombie(x: int, y: int, z: int) {
+  summon("minecraft:zombie", x, y, z);
+}
+fn main() {
+  spawn_zombie(1, 2, 3);
+}
+`
+    const result = compile(callerSource, { namespace: 'test', mcVersion: McVersion.v1_19 })
+    const fn = getMcFunction(result.files, 'main')
+    // Should call the function but NOT use "with storage"
+    expect(fn).not.toContain('with storage')
+    expect(fn).toContain('function test:spawn_zombie')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Default version produces macro syntax
+// ---------------------------------------------------------------------------
+
+describe('codegen — default version (no mcVersion specified)', () => {
+  it('uses macro syntax by default', () => {
+    const result = compile(macroSource, { namespace: 'test' })
+    const fn = getMcFunction(result.files, 'spawn_zombie')
+    expect(fn).toContain('$summon')
+  })
+})

package/{src2 → src}/__tests__/mir/arithmetic.test.ts

@@ -1,5 +1,5 @@
-import { Lexer } from '../../../src/lexer'
-import { Parser } from '../../../src/parser'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
 import { lowerToHIR } from '../../hir/lower'
 import { lowerToMIR } from '../../mir/lower'
 import { verifyMIR } from '../../mir/verify'

package/{src2 → src}/__tests__/mir/control-flow.test.ts

@@ -1,5 +1,5 @@
-import { Lexer } from '../../../src/lexer'
-import { Parser } from '../../../src/parser'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
 import { lowerToHIR } from '../../hir/lower'
 import { lowerToMIR } from '../../mir/lower'
 import { verifyMIR } from '../../mir/verify'

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')
+  })
+})