redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/emit/modules-branches.test.ts

@@ -0,0 +1,90 @@
+import { compileModules } from '../../emit/modules'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  return files.find(f => f.path.includes(pathSubstr))?.content
+}
+
+describe('emit/modules branch coverage', () => {
+  test('rewrites imported helpers through foreach and context blocks', () => {
+    const result = compileModules([
+      {
+        name: 'lib',
+        source: [
+          'module lib;',
+          'export fn helper(): int { return 1; }',
+          '',
+        ].join('\n'),
+      },
+      {
+        name: 'main',
+        source: [
+          'import lib::helper;',
+          'fn entry(): int {',
+          '  let nums: int[] = [1, 2];',
+          '  foreach (n in @a) at @s {',
+          '    let x: int = helper();',
+          '  }',
+          '  as @a { let y: int = helper(); }',
+          '  at @s { let z: int = helper(); }',
+          '  as @a at @s { let w: int = helper(); }',
+          '  for item in nums {',
+          '    let value: int = helper() + item;',
+          '  }',
+          '  return helper();',
+          '}',
+          '',
+        ].join('\n'),
+      },
+    ], { namespace: 'mod_ctx' })
+
+    const allContent = result.files.map(file => file.content).join('\n')
+    expect(allContent).toContain('function mod_ctx:lib/helper')
+  })
+
+  test('rewrites destructuring, tuple, index, member assign, invoke, and static call inputs', () => {
+    const result = compileModules([
+      {
+        name: 'lib',
+        source: [
+          'module lib;',
+          'export fn helper(): int { return 2; }',
+          '',
+        ].join('\n'),
+      },
+      {
+        name: 'main',
+        source: [
+          'import lib::helper;',
+          'struct Box { value: int }',
+          'struct Util {}',
+          'impl Box {',
+          '  fn bump(self): int {',
+          '    return self.value + helper();',
+          '  }',
+          '}',
+          'impl Util {',
+          '  fn build(n: int): int {',
+          '    return n + helper();',
+          '  }',
+          '}',
+          'fn pair(): (int, int) { return (helper(), helper()); }',
+          'fn entry(): int {',
+          '  let (a, b) = pair();',
+          '  let nums: int[] = [helper(), helper()];',
+          '  let bx: Box = Box { value: helper() };',
+          '  bx.value = helper();',
+          '  nums[0] = helper();',
+          '  let first: int = nums[0];',
+          '  let total: int = bx.bump() + Util::build(helper()) + a + b + first;',
+          '  return total;',
+          '}',
+          '',
+        ].join('\n'),
+      },
+    ], { namespace: 'mod_expr' })
+
+    expect(result.files.some(file => file.path.includes('entry.mcfunction'))).toBe(true)
+    expect(getFile(result.files, 'box/bump.mcfunction')).toContain('function mod_expr:lib/helper')
+    expect(getFile(result.files, 'entry.mcfunction')).toContain('function mod_expr:lib/helper')
+  })
+})

package/src/__tests__/emit/modules-coverage.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Additional coverage for src/emit/modules.ts
+ *
+ * Targets:
+ * - compileModules with 0 modules (throws)
+ * - declared module name mismatch (throws)
+ * - wildcard import (*)
+ * - import from non-existent module (throws)
+ * - import symbol not exported (throws)
+ * - circular import detection
+ * - cross-module DCE (library function pruned when not reachable)
+ * - named module load tag rename
+ * - multiple modules merging tick/load tags
+ */
+
+import { compileModules } from '../../emit/modules'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string) {
+  return files.find(f => f.path.includes(pathSubstr))
+}
+
+describe('compileModules — error paths', () => {
+  test('throws when no modules provided', () => {
+    expect(() => compileModules([])).toThrow()
+  })
+
+  test('throws when declared module name mismatches registered name', () => {
+    expect(() => compileModules([
+      { name: 'wrong', source: 'module actual; export fn foo(): int { return 1; }' },
+    ])).toThrow(/declares name/)
+  })
+
+  test('throws when importing non-existent module', () => {
+    expect(() => compileModules([
+      { name: 'main', source: 'import nonexistent::foo; fn bar(): int { return foo(); }' },
+    ])).toThrow(/not found/)
+  })
+
+  test('throws when importing unexported symbol', () => {
+    expect(() => compileModules([
+      {
+        name: 'lib',
+        source: 'module lib; fn private_fn(): int { return 0; }',
+      },
+      {
+        name: 'main',
+        source: 'import lib::private_fn; fn main(): int { return private_fn(); }',
+      },
+    ])).toThrow(/does not export/)
+  })
+
+  test('throws on circular imports', () => {
+    expect(() => compileModules([
+      { name: 'a', source: 'module a; import b::bar; export fn foo(): int { return bar(); }' },
+      { name: 'b', source: 'module b; import a::foo; export fn bar(): int { return foo(); }' },
+    ])).toThrow(/Circular/)
+  })
+})
+
+describe('compileModules — wildcard import (*)', () => {
+  test('wildcard import brings in all exports', () => {
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn double(n: int): int { return n * 2; }
+          export fn triple(n: int): int { return n * 3; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import math::*;
+          fn calc(): int {
+            let a: int = double(3);
+            let b: int = triple(2);
+            return a + b;
+          }
+        `,
+      },
+    ], { namespace: 'wildcard' })
+
+    expect(result.files.length).toBeGreaterThan(0)
+    const calc = getFile(result.files, 'calc.mcfunction')
+    expect(calc).toBeDefined()
+    expect(calc!.content).toContain('function wildcard:math/double')
+  })
+})
+
+describe('compileModules — load/tick tag merging', () => {
+  test('multiple modules with @load merge tags', () => {
+    const result = compileModules([
+      {
+        name: 'a',
+        source: `
+          module a;
+          @load fn init_a() {}
+        `,
+      },
+      {
+        name: 'b',
+        source: `
+          module b;
+          @load fn init_b() {}
+        `,
+      },
+    ], { namespace: 'multimod' })
+
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const parsed = JSON.parse(loadJson!.content) as { values: string[] }
+    expect(parsed.values.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test('multiple modules with @tick merge tags', () => {
+    const result = compileModules([
+      {
+        name: 'a',
+        source: `
+          module a;
+          @tick fn loop_a() {}
+        `,
+      },
+      {
+        name: 'b',
+        source: `
+          module b;
+          @tick fn loop_b() {}
+        `,
+      },
+    ], { namespace: 'tickmod' })
+
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeDefined()
+    const parsed = JSON.parse(tickJson!.content) as { values: string[] }
+    expect(parsed.values.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test('named module load path renamed to avoid collision', () => {
+    const result = compileModules([
+      {
+        name: 'mymod',
+        source: `
+          module mymod;
+          @load fn init() {}
+          export fn helper(): int { return 42; }
+        `,
+      },
+    ], { namespace: 'loadtest' })
+
+    // The load function should be at mymod/_load.mcfunction, not load.mcfunction
+    const loadFile = getFile(result.files, 'mymod/_load')
+    expect(loadFile).toBeDefined()
+
+    // load.json should reference the renamed path
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const parsed = JSON.parse(loadJson!.content) as { values: string[] }
+    expect(parsed.values.some(v => v.includes('mymod/_load'))).toBe(true)
+  })
+})
+
+describe('compileModules — cross-module DCE', () => {
+  test('exported but unimported functions are DCE-pruned', () => {
+    const result = compileModules([
+      {
+        name: 'lib',
+        source: `
+          module lib;
+          export fn used(): int { return 1; }
+          export fn never_used(): int { return 999; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import lib::used;
+          fn entry(): int { return used(); }
+        `,
+      },
+    ], { namespace: 'dce' })
+
+    const paths = result.files.map(f => f.path)
+    // 'used' should be in output
+    expect(paths.some(p => p.includes('lib/used'))).toBe(true)
+    // 'never_used' should be pruned (DCE)
+    expect(paths.some(p => p.includes('lib/never_used'))).toBe(false)
+  })
+
+  test('exported function reachable via calls is kept', () => {
+    const result = compileModules([
+      {
+        name: 'lib',
+        source: `
+          module lib;
+          export fn a(): int { return b(); }
+          export fn b(): int { return 42; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import lib::a;
+          fn entry(): int { return a(); }
+        `,
+      },
+    ], { namespace: 'dce2' })
+
+    const paths = result.files.map(f => f.path)
+    // a should be present (it's imported)
+    expect(paths.some(p => p.includes('lib/a'))).toBe(true)
+    // entry should also be present
+    expect(paths.some(p => p.includes('entry'))).toBe(true)
+  })
+})
+
+describe('compileModules — single anonymous module', () => {
+  test('compiles a single module without module declaration', () => {
+    const result = compileModules([
+      {
+        name: 'standalone',
+        source: `
+          fn hello(): int { return 42; }
+        `,
+      },
+    ], { namespace: 'sa' })
+
+    expect(result.files.length).toBeGreaterThan(0)
+    const hello = getFile(result.files, 'hello.mcfunction')
+    expect(hello).toBeDefined()
+  })
+
+  test('uses default namespace when none specified', () => {
+    const result = compileModules([
+      { name: 'mod', source: 'fn f(): int { return 0; }' },
+    ])
+    // Default namespace is 'redscript'
+    expect(result.files.some(f => f.path.includes('redscript'))).toBe(true)
+  })
+})

package/src/__tests__/emit/modules-errors.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Error-path coverage for src/emit/modules.ts
+ *
+ * Targets:
+ * - Empty modules array (throws)
+ * - Module name mismatch (declares vs registered)
+ * - Unknown imported module
+ * - Exporting non-existent symbol
+ * - Circular imports
+ * - Wildcard imports (import mod::*)
+ */
+
+import { compileModules } from '../../emit/modules'
+
+// ── Error paths ───────────────────────────────────────────────────────────
+
+describe('compileModules — error paths', () => {
+  test('throws on empty modules array', () => {
+    expect(() => compileModules([])).toThrow()
+  })
+
+  test('throws when module declares different name than registered', () => {
+    expect(() =>
+      compileModules([
+        {
+          name: 'wrongname',
+          source: `
+            module actualname;
+            fn hello(): int { return 1; }
+          `,
+        },
+      ], { namespace: 'err' })
+    ).toThrow(/declares name/)
+  })
+
+  test('throws when importing unknown module', () => {
+    expect(() =>
+      compileModules([
+        {
+          name: 'main',
+          source: `
+            import nonexistent::foo;
+            fn entry(): int { return 0; }
+          `,
+        },
+      ], { namespace: 'err2' })
+    ).toThrow()
+  })
+
+  test('throws on circular imports', () => {
+    expect(() =>
+      compileModules([
+        {
+          name: 'a',
+          source: `
+            module a;
+            import b::bar;
+            export fn foo(): int { return bar(); }
+          `,
+        },
+        {
+          name: 'b',
+          source: `
+            module b;
+            import a::foo;
+            export fn bar(): int { return foo(); }
+          `,
+        },
+      ], { namespace: 'circ' })
+    ).toThrow(/[Cc]ircular/)
+  })
+
+  test('throws when importing symbol not exported by module', () => {
+    expect(() =>
+      compileModules([
+        {
+          name: 'lib',
+          source: `
+            module lib;
+            fn private_fn(): int { return 99; }
+          `,
+        },
+        {
+          name: 'main',
+          source: `
+            import lib::private_fn;
+            fn entry(): int { return private_fn(); }
+          `,
+        },
+      ], { namespace: 'err3' })
+    ).toThrow()
+  })
+})
+
+// ── Wildcard import ────────────────────────────────────────────────────────
+
+describe('compileModules — wildcard imports', () => {
+  test('import module::* imports all exported symbols', () => {
+    const result = compileModules([
+      {
+        name: 'utils',
+        source: `
+          module utils;
+          export fn add(a: int, b: int): int { return a + b; }
+          export fn sub(a: int, b: int): int { return a - b; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import utils::*;
+          fn entry(): int { return add(1, 2); }
+        `,
+      },
+    ], { namespace: 'wild' })
+
+    expect(result.files.length).toBeGreaterThan(0)
+  })
+})
+
+// ── Single module without module declaration ───────────────────────────────
+
+describe('compileModules — single module no declaration', () => {
+  test('single module with no module keyword compiles', () => {
+    const result = compileModules([
+      {
+        name: 'standalone',
+        source: `
+          fn greet(): int { return 42; }
+        `,
+      },
+    ], { namespace: 'solo' })
+
+    expect(result.files.length).toBeGreaterThan(0)
+    expect(result.warnings).toBeDefined()
+  })
+})
+
+// ── Multiple modules ────────────────────────────────────────────────────────
+
+describe('compileModules — multi-module compilation', () => {
+  test('three module chain: a → b → c', () => {
+    const result = compileModules([
+      {
+        name: 'c',
+        source: `
+          module c;
+          export fn base(): int { return 1; }
+        `,
+      },
+      {
+        name: 'b',
+        source: `
+          module b;
+          import c::base;
+          export fn mid(): int { return base(); }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import b::mid;
+          fn entry(): int { return mid(); }
+        `,
+      },
+    ], { namespace: 'chain' })
+
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true)
+  })
+
+  test('two modules with matching declared names compile fine', () => {
+    const result = compileModules([
+      {
+        name: 'math',
+        source: `
+          module math;
+          export fn square(n: int): int { return n * n; }
+        `,
+      },
+      {
+        name: 'app',
+        source: `
+          module app;
+          import math::square;
+          fn compute(): int { return square(5); }
+        `,
+      },
+    ], { namespace: 'mathapp' })
+
+    expect(result.files.some(f => f.path.includes('compute') || f.path.includes('square'))).toBe(true)
+  })
+})