redscript-mc 2.4.1 → 2.6.0

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

@@ -1,185 +0,0 @@
-"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

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

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

@@ -1,221 +0,0 @@
-"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

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

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

@@ -1,130 +0,0 @@
-"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

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