redscript-mc 2.0.0 → 2.1.1

package/dist/src/__tests__/mc-version.test.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const mc_version_1 = require("../types/mc-version");
+// ---------------------------------------------------------------------------
+// parseMcVersion
+// ---------------------------------------------------------------------------
+describe('parseMcVersion', () => {
+    it('parses "1.21" correctly', () => {
+        expect((0, mc_version_1.parseMcVersion)('1.21')).toBe(mc_version_1.McVersion.v1_21);
+    });
+    it('parses "1.20.2" correctly', () => {
+        expect((0, mc_version_1.parseMcVersion)('1.20.2')).toBe(mc_version_1.McVersion.v1_20_2);
+    });
+    it('parses "1.20" correctly', () => {
+        expect((0, mc_version_1.parseMcVersion)('1.20')).toBe(mc_version_1.McVersion.v1_20);
+    });
+    it('parses "1.19" correctly', () => {
+        expect((0, mc_version_1.parseMcVersion)('1.19')).toBe(mc_version_1.McVersion.v1_19);
+    });
+    it('parses "1.21.4" correctly', () => {
+        expect((0, mc_version_1.parseMcVersion)('1.21.4')).toBe(mc_version_1.McVersion.v1_21_4);
+    });
+    it('throws on invalid format', () => {
+        expect(() => (0, mc_version_1.parseMcVersion)('1')).toThrow();
+        expect(() => (0, mc_version_1.parseMcVersion)('abc')).toThrow();
+        expect(() => (0, mc_version_1.parseMcVersion)('2.0')).toThrow();
+        expect(() => (0, mc_version_1.parseMcVersion)('1.20.2.1')).toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// compareMcVersion
+// ---------------------------------------------------------------------------
+describe('compareMcVersion', () => {
+    it('returns 0 for equal versions', () => {
+        expect((0, mc_version_1.compareMcVersion)(mc_version_1.McVersion.v1_21, mc_version_1.McVersion.v1_21)).toBe(0);
+    });
+    it('returns negative when a < b', () => {
+        expect((0, mc_version_1.compareMcVersion)(mc_version_1.McVersion.v1_20, mc_version_1.McVersion.v1_21)).toBeLessThan(0);
+        expect((0, mc_version_1.compareMcVersion)(mc_version_1.McVersion.v1_20_2, mc_version_1.McVersion.v1_21)).toBeLessThan(0);
+        expect((0, mc_version_1.compareMcVersion)(mc_version_1.McVersion.v1_19, mc_version_1.McVersion.v1_20_2)).toBeLessThan(0);
+    });
+    it('returns positive when a > b', () => {
+        expect((0, mc_version_1.compareMcVersion)(mc_version_1.McVersion.v1_21, mc_version_1.McVersion.v1_20)).toBeGreaterThan(0);
+        expect((0, mc_version_1.compareMcVersion)(mc_version_1.McVersion.v1_21_4, mc_version_1.McVersion.v1_21)).toBeGreaterThan(0);
+    });
+    it('1.20.2 >= 1.20.2 boundary', () => {
+        expect(mc_version_1.McVersion.v1_20_2 >= mc_version_1.McVersion.v1_20_2).toBe(true);
+        expect(mc_version_1.McVersion.v1_20 >= mc_version_1.McVersion.v1_20_2).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// Default version
+// ---------------------------------------------------------------------------
+describe('DEFAULT_MC_VERSION', () => {
+    it('is 1.21', () => {
+        expect(mc_version_1.DEFAULT_MC_VERSION).toBe(mc_version_1.McVersion.v1_21);
+    });
+});
+// ---------------------------------------------------------------------------
+// Codegen — macro syntax (>= 1.20.2)
+// ---------------------------------------------------------------------------
+function getMcFunction(files, fnSuffix) {
+    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 = (0, index_1.compile)(macroSource, { namespace: 'test', mcVersion: mc_version_1.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 = (0, index_1.compile)(callerSource, { namespace: 'test', mcVersion: mc_version_1.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 = (0, index_1.compile)(macroSource, { namespace: 'test', mcVersion: mc_version_1.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 = (0, index_1.compile)(macroSource, { namespace: 'test', mcVersion: mc_version_1.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 = (0, index_1.compile)(macroSource, { namespace: 'test', mcVersion: mc_version_1.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 = (0, index_1.compile)(callerSource, { namespace: 'test', mcVersion: mc_version_1.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 = (0, index_1.compile)(macroSource, { namespace: 'test' });
+        const fn = getMcFunction(result.files, 'spawn_zombie');
+        expect(fn).toContain('$summon');
+    });
+});
+//# sourceMappingURL=mc-version.test.js.map

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const lexer_1 = require("../../../src/lexer");
-const parser_1 = require("../../../src/parser");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
 const lower_1 = require("../../hir/lower");
 const lower_2 = require("../../mir/lower");
 const verify_1 = require("../../mir/verify");

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const lexer_1 = require("../../../src/lexer");
-const parser_1 = require("../../../src/parser");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
 const lower_1 = require("../../hir/lower");
 const lower_2 = require("../../mir/lower");
 const verify_1 = require("../../mir/verify");

package/dist/src/__tests__/modules.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Phase 5b — Module system tests
+ *
+ * Tests for `module <name>;`, `export fn`, `import <mod>::<sym>;`, and
+ * cross-module function calls with namespace-isolated scoreboards.
+ */
+export {};

package/dist/src/__tests__/modules.test.js

@@ -0,0 +1,333 @@
+"use strict";
+/**
+ * Phase 5b — Module system tests
+ *
+ * Tests for `module <name>;`, `export fn`, `import <mod>::<sym>;`, and
+ * cross-module function calls with namespace-isolated scoreboards.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../emit/modules");
+function getFile(files, substr) {
+    return files.find(f => f.path.includes(substr))?.content;
+}
+function getPath(files, substr) {
+    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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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(() => (0, modules_1.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(() => (0, modules_1.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(() => (0, modules_1.compileModules)([
+            {
+                name: 'main',
+                source: `
+          import nonexistent::foo;
+          fn main() { foo(); }
+        `,
+            },
+        ], { namespace: 'ns' })).toThrow(/not found/);
+    });
+    test('importing non-exported symbol throws', () => {
+        expect(() => (0, modules_1.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(() => (0, modules_1.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 = (0, modules_1.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 = (0, modules_1.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');
+    });
+});
+//# sourceMappingURL=modules.test.js.map

package/dist/src/__tests__/optimizer/coroutine.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for the coroutine transform pass.
+ *
+ * Verifies:
+ * - Loop-containing functions are split into continuations
+ * - Dispatcher @tick function is generated
+ * - batch parameter controls iteration count
+ * - onDone callback is called when coroutine completes
+ * - Variables live across yield points are promoted
+ * - Functions without loops get single-continuation wrapping
+ */
+export {};