redscript-mc 2.4.0 → 2.5.0

package/dist/src2/__tests__/lir/types.test.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('LIR types — Slot', () => {
+    test('Slot has player and obj fields', () => {
+        const slot = { player: '$t0', obj: '__test' };
+        expect(slot.player).toBe('$t0');
+        expect(slot.obj).toBe('__test');
+    });
+});
+describe('LIR types — instructions', () => {
+    test('score_set instruction', () => {
+        const instr = { kind: 'score_set', dst: { player: '$x', obj: '__ns' }, value: 42 };
+        expect(instr.kind).toBe('score_set');
+    });
+    test('score_copy instruction', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const src = { player: '$y', obj: '__ns' };
+        const instr = { kind: 'score_copy', dst, src };
+        expect(instr.kind).toBe('score_copy');
+    });
+    test('score arithmetic instructions', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const src = { player: '$y', obj: '__ns' };
+        const ops = ['score_add', 'score_sub', 'score_mul', 'score_div', 'score_mod'];
+        for (const kind of ops) {
+            const instr = { kind, dst, src };
+            expect(instr.kind).toBe(kind);
+        }
+    });
+    test('score_min, score_max instructions', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const src = { player: '$y', obj: '__ns' };
+        const min = { kind: 'score_min', dst, src };
+        const max = { kind: 'score_max', dst, src };
+        expect(min.kind).toBe('score_min');
+        expect(max.kind).toBe('score_max');
+    });
+    test('score_swap instruction', () => {
+        const a = { player: '$x', obj: '__ns' };
+        const b = { player: '$y', obj: '__ns' };
+        const instr = { kind: 'score_swap', a, b };
+        expect(instr.kind).toBe('score_swap');
+    });
+    test('store_cmd_to_score instruction', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const cmd = { kind: 'call', fn: 'test:foo' };
+        const instr = { kind: 'store_cmd_to_score', dst, cmd };
+        expect(instr.kind).toBe('store_cmd_to_score');
+    });
+    test('store_score_to_nbt instruction', () => {
+        const instr = {
+            kind: 'store_score_to_nbt',
+            ns: 'rs:data', path: 'value', type: 'int', scale: 1,
+            src: { player: '$x', obj: '__ns' },
+        };
+        expect(instr.kind).toBe('store_score_to_nbt');
+    });
+    test('store_nbt_to_score instruction', () => {
+        const instr = {
+            kind: 'store_nbt_to_score',
+            dst: { player: '$x', obj: '__ns' },
+            ns: 'rs:data', path: 'value', scale: 1,
+        };
+        expect(instr.kind).toBe('store_nbt_to_score');
+    });
+    test('nbt_set_literal instruction', () => {
+        const instr = { kind: 'nbt_set_literal', ns: 'rs:data', path: 'x', value: '42' };
+        expect(instr.kind).toBe('nbt_set_literal');
+    });
+    test('nbt_copy instruction', () => {
+        const instr = {
+            kind: 'nbt_copy',
+            srcNs: 'rs:a', srcPath: 'x',
+            dstNs: 'rs:b', dstPath: 'y',
+        };
+        expect(instr.kind).toBe('nbt_copy');
+    });
+    test('call instruction', () => {
+        const instr = { kind: 'call', fn: 'test:foo' };
+        expect(instr.kind).toBe('call');
+    });
+    test('call_macro instruction', () => {
+        const instr = { kind: 'call_macro', fn: 'test:draw', storage: 'rs:macro_args' };
+        expect(instr.kind).toBe('call_macro');
+    });
+    test('call_if_matches instruction', () => {
+        const instr = {
+            kind: 'call_if_matches',
+            fn: 'test:branch',
+            slot: { player: '$cond', obj: '__ns' },
+            range: '1',
+        };
+        expect(instr.kind).toBe('call_if_matches');
+    });
+    test('call_unless_matches instruction', () => {
+        const instr = {
+            kind: 'call_unless_matches',
+            fn: 'test:branch',
+            slot: { player: '$cond', obj: '__ns' },
+            range: '1',
+        };
+        expect(instr.kind).toBe('call_unless_matches');
+    });
+    test('call_if_score instruction', () => {
+        const instr = {
+            kind: 'call_if_score',
+            fn: 'test:check',
+            a: { player: '$x', obj: '__ns' },
+            op: 'lt',
+            b: { player: '$y', obj: '__ns' },
+        };
+        expect(instr.kind).toBe('call_if_score');
+    });
+    test('call_unless_score instruction', () => {
+        const instr = {
+            kind: 'call_unless_score',
+            fn: 'test:check',
+            a: { player: '$x', obj: '__ns' },
+            op: 'ge',
+            b: { player: '$y', obj: '__ns' },
+        };
+        expect(instr.kind).toBe('call_unless_score');
+    });
+    test('call_context instruction', () => {
+        const instr = {
+            kind: 'call_context',
+            fn: 'test:helper',
+            subcommands: [{ kind: 'as', selector: '@e[tag=foo]' }, { kind: 'at_self' }],
+        };
+        expect(instr.kind).toBe('call_context');
+    });
+    test('return_value instruction', () => {
+        const instr = { kind: 'return_value', slot: { player: '$result', obj: '__ns' } };
+        expect(instr.kind).toBe('return_value');
+    });
+    test('macro_line instruction', () => {
+        const instr = { kind: 'macro_line', template: '$particle end_rod ^$(px) ^$(py) ^5' };
+        expect(instr.kind).toBe('macro_line');
+    });
+    test('raw instruction', () => {
+        const instr = { kind: 'raw', cmd: 'say hello' };
+        expect(instr.kind).toBe('raw');
+    });
+});
+describe('LIR types — LIRFunction', () => {
+    test('basic function structure', () => {
+        const fn = {
+            name: 'main',
+            instructions: [
+                { kind: 'score_set', dst: { player: '$x', obj: '__ns' }, value: 0 },
+            ],
+            isMacro: false,
+            macroParams: [],
+        };
+        expect(fn.name).toBe('main');
+        expect(fn.instructions).toHaveLength(1);
+        expect(fn.isMacro).toBe(false);
+        expect(fn.macroParams).toEqual([]);
+    });
+    test('macro function structure', () => {
+        const fn = {
+            name: 'draw_pt',
+            instructions: [
+                { kind: 'macro_line', template: '$particle end_rod ^$(px) ^$(py) ^5' },
+            ],
+            isMacro: true,
+            macroParams: ['px', 'py'],
+        };
+        expect(fn.isMacro).toBe(true);
+        expect(fn.macroParams).toEqual(['px', 'py']);
+    });
+});
+describe('LIR types — LIRModule', () => {
+    test('module structure', () => {
+        const mod = {
+            functions: [],
+            namespace: 'mypack',
+            objective: '__mypack',
+        };
+        expect(mod.namespace).toBe('mypack');
+        expect(mod.objective).toBe('__mypack');
+        expect(mod.functions).toEqual([]);
+    });
+});
+//# sourceMappingURL=types.test.js.map

package/dist/src2/__tests__/lir/verify.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src2/__tests__/lir/verify.test.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const verify_1 = require("../../lir/verify");
+const OBJ = '__test';
+const NS = 'test';
+function mkModule(functions) {
+    return { functions, namespace: NS, objective: OBJ };
+}
+function mkFn(name, instructions, isMacro = false, macroParams = []) {
+    return { name, instructions, isMacro, macroParams };
+}
+function slot(name) {
+    return { player: `$${name}`, obj: OBJ };
+}
+// ---------------------------------------------------------------------------
+// Objective checks
+// ---------------------------------------------------------------------------
+describe('LIR verifier — objective checks', () => {
+    test('accepts slots with correct objective', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: slot('x'), value: 42 },
+                { kind: 'score_copy', dst: slot('y'), src: slot('x') },
+            ]),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('rejects slot with wrong objective', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: { player: '$x', obj: '__wrong' }, value: 42 },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('objective');
+        expect(errors[0].message).toContain('__wrong');
+    });
+    test('rejects wrong objective in src slot', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_copy', dst: slot('x'), src: { player: '$y', obj: '__bad' } },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('__bad');
+    });
+    test('checks slots in score_swap', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_swap', a: { player: '$x', obj: '__bad' }, b: slot('y') },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('__bad');
+    });
+    test('checks slots in store_cmd_to_score (recursive)', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                {
+                    kind: 'store_cmd_to_score',
+                    dst: slot('r'),
+                    cmd: {
+                        kind: 'call_if_score',
+                        fn: 'test:main',
+                        a: { player: '$a', obj: '__bad' },
+                        op: 'eq',
+                        b: slot('b'),
+                    },
+                },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('__bad');
+    });
+    test('checks slot in call_if_matches', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                {
+                    kind: 'call_if_matches',
+                    fn: 'test:main',
+                    slot: { player: '$c', obj: '__bad' },
+                    range: '1',
+                },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+    });
+    test('checks slot in return_value', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'return_value', slot: { player: '$r', obj: '__bad' } },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Function reference checks
+// ---------------------------------------------------------------------------
+describe('LIR verifier — function references', () => {
+    test('accepts call to existing function', () => {
+        const mod = mkModule([
+            mkFn('main', [{ kind: 'call', fn: 'test:helper' }]),
+            mkFn('helper', []),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('rejects call to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [{ kind: 'call', fn: 'test:nonexistent' }]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+        expect(errors[0].message).toContain('nonexistent');
+    });
+    test('rejects call_macro to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [{ kind: 'call_macro', fn: 'test:missing', storage: 'rs:macro_args' }]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+    test('rejects call_if_matches to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'call_if_matches', fn: 'test:missing', slot: slot('c'), range: '1' },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+    test('rejects call_context to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'call_context', fn: 'test:missing', subcommands: [{ kind: 'at_self' }] },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+    test('checks function refs inside store_cmd_to_score', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                {
+                    kind: 'store_cmd_to_score',
+                    dst: slot('r'),
+                    cmd: { kind: 'call', fn: 'test:missing' },
+                },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro line checks
+// ---------------------------------------------------------------------------
+describe('LIR verifier — macro_line', () => {
+    test('accepts macro_line in macro function', () => {
+        const mod = mkModule([
+            mkFn('draw', [
+                { kind: 'macro_line', template: '$particle end_rod ^$(px)' },
+            ], true, ['px']),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('rejects macro_line in non-macro function', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'macro_line', template: '$particle end_rod ^$(px)' },
+            ], false),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('macro_line');
+        expect(errors[0].message).toContain('non-macro');
+    });
+});
+// ---------------------------------------------------------------------------
+// Clean module
+// ---------------------------------------------------------------------------
+describe('LIR verifier — clean module', () => {
+    test('accepts a well-formed module', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: slot('t0'), value: 1 },
+                { kind: 'score_set', dst: slot('t1'), value: 2 },
+                { kind: 'score_copy', dst: slot('r'), src: slot('t0') },
+                { kind: 'score_add', dst: slot('r'), src: slot('t1') },
+                { kind: 'call', fn: 'test:helper' },
+                { kind: 'return_value', slot: slot('r') },
+            ]),
+            mkFn('helper', [
+                { kind: 'raw', cmd: 'say hello' },
+            ]),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('raw and nbt instructions do not trigger errors', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'raw', cmd: 'say hi' },
+                { kind: 'nbt_set_literal', ns: 'rs:data', path: 'x', value: '42' },
+                { kind: 'nbt_copy', srcNs: 'rs:a', srcPath: 'x', dstNs: 'rs:b', dstPath: 'y' },
+            ]),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+});
+//# sourceMappingURL=verify.test.js.map

package/dist/src2/__tests__/mir/arithmetic.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src2/__tests__/mir/arithmetic.test.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../../src/lexer");
+const parser_1 = require("../../../src/parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+function compile(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    return (0, lower_2.lowerToMIR)(hir);
+}
+function getEntryInstrs(mod) {
+    const fn = mod.functions[0];
+    const entry = fn.blocks.find(b => b.id === fn.entry);
+    return entry.instrs;
+}
+describe('MIR lowering — integer arithmetic', () => {
+    test('simple addition: let x = a + b', () => {
+        const mod = compile('fn f(a: int, b: int): int { return a + b; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        // Should have an add instruction
+        const addInstr = instrs.find(i => i.kind === 'add');
+        expect(addInstr).toBeDefined();
+        expect(addInstr.kind).toBe('add');
+    });
+    test('chained arithmetic: a + b * c', () => {
+        const mod = compile('fn f(a: int, b: int, c: int): int { return a + b * c; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        // Should have both mul and add
+        const kinds = instrs.map(i => i.kind);
+        expect(kinds).toContain('mul');
+        expect(kinds).toContain('add');
+        // mul should come before add (b*c computed first)
+        const mulIdx = kinds.indexOf('mul');
+        const addIdx = kinds.indexOf('add');
+        expect(mulIdx).toBeLessThan(addIdx);
+    });
+    test('subtraction and division', () => {
+        const mod = compile('fn f(a: int, b: int): int { return (a - b) / b; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        const kinds = instrs.map(i => i.kind);
+        expect(kinds).toContain('sub');
+        expect(kinds).toContain('div');
+    });
+    test('modulo', () => {
+        const mod = compile('fn f(a: int, b: int): int { return a % b; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        expect(instrs.some(i => i.kind === 'mod')).toBe(true);
+    });
+    test('negation', () => {
+        const mod = compile('fn f(a: int): int { return -a; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        expect(instrs.some(i => i.kind === 'neg')).toBe(true);
+    });
+    test('not operator', () => {
+        const mod = compile('fn f(a: bool): bool { return !a; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        expect(instrs.some(i => i.kind === 'not')).toBe(true);
+    });
+    test('comparison operators produce cmp instructions', () => {
+        const mod = compile('fn f(a: int, b: int): bool { return a < b; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        const cmpInstr = instrs.find(i => i.kind === 'cmp');
+        expect(cmpInstr).toBeDefined();
+        expect(cmpInstr.op).toBe('lt');
+    });
+    test('let binding produces copy instruction', () => {
+        const mod = compile('fn f(a: int): int { let x: int = a; return x; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        expect(instrs.some(i => i.kind === 'copy')).toBe(true);
+    });
+    test('constant literal produces const instruction', () => {
+        const mod = compile('fn f(): int { return 42; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        // The return terminator should have the const value
+        const fn = mod.functions[0];
+        const entry = fn.blocks.find(b => b.id === fn.entry);
+        expect(entry.term.kind).toBe('return');
+        const ret = entry.term;
+        expect(ret.value).toEqual({ kind: 'const', value: 42 });
+    });
+    test('function call produces call instruction', () => {
+        const mod = compile('fn add(a: int, b: int): int { return a + b; } fn f(): int { return add(1, 2); }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        // f is the second function
+        const fn = mod.functions[1];
+        const entry = fn.blocks.find(b => b.id === fn.entry);
+        const callInstr = entry.instrs.find(i => i.kind === 'call');
+        expect(callInstr).toBeDefined();
+        expect(callInstr.fn).toBe('add');
+        expect(callInstr.args).toHaveLength(2);
+    });
+    test('3-address form: each instruction has fresh dst', () => {
+        const mod = compile('fn f(a: int, b: int, c: int): int { return a + b + c; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const instrs = getEntryInstrs(mod);
+        const dsts = instrs.filter(i => 'dst' in i).map(i => i.dst);
+        // All destination temps should be unique
+        expect(new Set(dsts).size).toBe(dsts.length);
+    });
+});
+describe('MIR lowering — module structure', () => {
+    test('namespace and objective set correctly', () => {
+        const mod = compile('fn f(): void {}');
+        expect(mod.namespace).toBe('test');
+        expect(mod.objective).toBe('__test');
+    });
+    test('multiple functions', () => {
+        const mod = compile('fn a(): void {} fn b(): void {} fn c(): void {}');
+        expect(mod.functions).toHaveLength(3);
+        expect(mod.functions.map(f => f.name)).toEqual(['a', 'b', 'c']);
+    });
+    test('function params are mapped to temps', () => {
+        const mod = compile('fn f(x: int, y: int): int { return x + y; }');
+        expect(mod.functions[0].params).toHaveLength(2);
+        expect(mod.functions[0].params[0].name).toMatch(/^t\d+$/);
+        expect(mod.functions[0].params[1].name).toMatch(/^t\d+$/);
+    });
+});
+//# sourceMappingURL=arithmetic.test.js.map

package/dist/src2/__tests__/mir/control-flow.test.d.ts

@@ -0,0 +1 @@
+export {};