redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/emit/modules-branches.test.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../../emit/modules");
+function getFile(files, pathSubstr) {
+    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 = (0, modules_1.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 = (0, modules_1.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');
+    });
+});
+//# sourceMappingURL=modules-branches.test.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+export {};

package/dist/src/__tests__/emit/modules-coverage.test.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../../emit/modules");
+function getFile(files, pathSubstr) {
+    return files.find(f => f.path.includes(pathSubstr));
+}
+describe('compileModules — error paths', () => {
+    test('throws when no modules provided', () => {
+        expect(() => (0, modules_1.compileModules)([])).toThrow();
+    });
+    test('throws when declared module name mismatches registered name', () => {
+        expect(() => (0, modules_1.compileModules)([
+            { name: 'wrong', source: 'module actual; export fn foo(): int { return 1; }' },
+        ])).toThrow(/declares name/);
+    });
+    test('throws when importing non-existent module', () => {
+        expect(() => (0, modules_1.compileModules)([
+            { name: 'main', source: 'import nonexistent::foo; fn bar(): int { return foo(); }' },
+        ])).toThrow(/not found/);
+    });
+    test('throws when importing unexported symbol', () => {
+        expect(() => (0, modules_1.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(() => (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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);
+        expect(parsed.values.length).toBeGreaterThanOrEqual(2);
+    });
+    test('multiple modules with @tick merge tags', () => {
+        const result = (0, modules_1.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);
+        expect(parsed.values.length).toBeGreaterThanOrEqual(2);
+    });
+    test('named module load path renamed to avoid collision', () => {
+        const result = (0, modules_1.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);
+        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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.compileModules)([
+            { name: 'mod', source: 'fn f(): int { return 0; }' },
+        ]);
+        // Default namespace is 'redscript'
+        expect(result.files.some(f => f.path.includes('redscript'))).toBe(true);
+    });
+});
+//# sourceMappingURL=modules-coverage.test.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * 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::*)
+ */
+export {};

package/dist/src/__tests__/emit/modules-errors.test.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * 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::*)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../../emit/modules");
+// ── Error paths ───────────────────────────────────────────────────────────
+describe('compileModules — error paths', () => {
+    test('throws on empty modules array', () => {
+        expect(() => (0, modules_1.compileModules)([])).toThrow();
+    });
+    test('throws when module declares different name than registered', () => {
+        expect(() => (0, modules_1.compileModules)([
+            {
+                name: 'wrongname',
+                source: `
+            module actualname;
+            fn hello(): int { return 1; }
+          `,
+            },
+        ], { namespace: 'err' })).toThrow(/declares name/);
+    });
+    test('throws when importing unknown module', () => {
+        expect(() => (0, modules_1.compileModules)([
+            {
+                name: 'main',
+                source: `
+            import nonexistent::foo;
+            fn entry(): int { return 0; }
+          `,
+            },
+        ], { namespace: 'err2' })).toThrow();
+    });
+    test('throws on circular imports', () => {
+        expect(() => (0, modules_1.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(() => (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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);
+    });
+});
+//# sourceMappingURL=modules-errors.test.js.map

package/dist/src/__tests__/emit/modules-rewrite.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Coverage for src/emit/modules.ts — rewriteCallsInProgram and rewriteStmt/rewriteExpr
+ *
+ * Targets the rewriting of various AST node types when module imports are resolved:
+ * - while stmt with imported call
+ * - for_range stmt with imported call
+ * - match stmt with imported call in arm
+ * - execute stmt with imported call in body
+ * - let_destruct with imported call
+ * - member/member_assign/index/index_assign expressions using imported fn
+ * - array_lit, struct_lit, tuple_lit with imported fn
+ * - invoke, assign, binary, unary expressions
+ * - implBlock methods are rewritten
+ * - return stmt with value using imported fn
+ * - if stmt with else using imported fn
+ */
+export {};