redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/mir/verify.test.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const verify_1 = require("../../mir/verify");
+function makeModule(functions) {
+    return { functions, namespace: 'test', objective: '__test' };
+}
+function makeBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+describe('MIR verifier — terminator checks', () => {
+    test('rejects block without proper terminator', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'const', dst: 't0', value: 42 }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('does not end with a terminator');
+    });
+    test('rejects terminator in non-terminal position', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [{ kind: 'jump', target: 'entry' }], // terminator in instrs
+                { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('terminator');
+        expect(errors[0].message).toContain('non-terminal position');
+    });
+    test('accepts valid terminator (return)', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('accepts valid terminator (jump)', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'jump', target: 'b1' }),
+                makeBlock('b1', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+});
+describe('MIR verifier — target existence', () => {
+    test('rejects jump to non-existent block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'jump', target: 'nonexistent' }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('non-existent target');
+    });
+    test('rejects branch to non-existent block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 1 },
+                ], { kind: 'branch', cond: { kind: 'temp', name: 't0' }, then: 'yes', else: 'no' }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBe(2); // both targets missing
+        expect(errors[0].message).toContain('non-existent target');
+    });
+});
+describe('MIR verifier — reachability', () => {
+    test('rejects unreachable block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'return', value: null }),
+                makeBlock('orphan', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('unreachable');
+        expect(errors[0].block).toBe('orphan');
+    });
+    test('accepts all blocks reachable via jumps', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'jump', target: 'b1' }),
+                makeBlock('b1', [], { kind: 'jump', target: 'b2' }),
+                makeBlock('b2', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('accepts blocks reachable via branch', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 1 },
+                ], { kind: 'branch', cond: { kind: 'temp', name: 't0' }, then: 'yes', else: 'no' }),
+                makeBlock('yes', [], { kind: 'return', value: null }),
+                makeBlock('no', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+});
+describe('MIR verifier — use-before-def', () => {
+    test('rejects use of undefined temp', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'copy', dst: 't0', src: { kind: 'temp', name: 'undefined_temp' } },
+                ], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('undefined_temp');
+        expect(errors[0].message).toContain('never defined');
+    });
+    test('accepts temps defined as params', () => {
+        const fn = {
+            name: 'good',
+            params: [{ name: 't0', isMacroParam: false }],
+            blocks: [
+                makeBlock('entry', [], { kind: 'return', value: { kind: 'temp', name: 't0' } }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('accepts temps defined in instructions', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 42 },
+                    { kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } },
+                ], { kind: 'return', value: { kind: 'temp', name: 't1' } }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('const operands do not require definition', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 5 },
+                    { kind: 'add', dst: 't1', a: { kind: 'temp', name: 't0' }, b: { kind: 'const', value: 3 } },
+                ], { kind: 'return', value: { kind: 'temp', name: 't1' } }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+});
+describe('MIR verifier — entry block', () => {
+    test('rejects missing entry block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('not_entry', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.some(e => e.message.includes('entry block'))).toBe(true);
+    });
+});
+//# sourceMappingURL=verify.test.js.map

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/block_merge.test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const block_merge_1 = require("../../optimizer/block_merge");
+function mkFn(blocks, entry = 'entry') {
+    return { name: 'test', params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ 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 = (0, block_merge_1.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 = (0, block_merge_1.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 = (0, block_merge_1.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 = (0, block_merge_1.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 = (0, block_merge_1.blockMerge)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].preds).toEqual([]);
+    });
+});
+//# sourceMappingURL=block_merge.test.js.map