redscript-mc 2.4.0 → 2.5.0

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

@@ -0,0 +1,559 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lower_1 = require("../../lir/lower");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const OBJ = '__test';
+const NS = 'test';
+function mkModule(functions) {
+    return { functions, namespace: NS, objective: OBJ };
+}
+function mkFn(name, blocks, params = [], isMacro = false) {
+    return { name, params, blocks, entry: 'entry', isMacro };
+}
+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 });
+/** Build a slot with the function-name prefix that LIR lowering adds */
+function slot(name, fn = 'main') {
+    return { player: `$${fn}_${name}`, obj: OBJ };
+}
+function findInstr(instrs, kind) {
+    return instrs.find(i => i.kind === kind);
+}
+function findAllInstrs(instrs, kind) {
+    return instrs.filter(i => i.kind === kind);
+}
+// ---------------------------------------------------------------------------
+// Constant lowering
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — constants', () => {
+    test('const → score_set', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 42 },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[0]).toEqual({
+            kind: 'score_set',
+            dst: slot('t0'),
+            value: 42,
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Copy lowering
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — copy', () => {
+    test('copy temp → score_copy', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 5 },
+                    { kind: 'copy', dst: 't1', src: t('t0') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[1]).toEqual({
+            kind: 'score_copy',
+            dst: slot('t1'),
+            src: slot('t0'),
+        });
+    });
+    test('copy const → score_set', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'copy', dst: 't0', src: c(10) },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[0]).toEqual({
+            kind: 'score_set',
+            dst: slot('t0'),
+            value: 10,
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Arithmetic lowering
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — arithmetic', () => {
+    test('add temps → score_copy + score_add', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'a', value: 3 },
+                    { kind: 'const', dst: 'b', value: 4 },
+                    { kind: 'add', dst: 'r', a: t('a'), b: t('b') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        // After two score_sets for a and b, we should see:
+        // score_copy $r = $a
+        // score_add $r += $b
+        const instrs = main.instructions;
+        expect(instrs[2]).toEqual({ kind: 'score_copy', dst: slot('r'), src: slot('a') });
+        expect(instrs[3]).toEqual({ kind: 'score_add', dst: slot('r'), src: slot('b') });
+    });
+    test('add with const operand → score_set + score_copy + score_set const + score_add', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'a', value: 3 },
+                    { kind: 'add', dst: 'r', a: t('a'), b: c(7) },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // score_set $a 3
+        // score_copy $r = $a
+        // score_set $__const_7 7
+        // score_add $r += $__const_7
+        expect(instrs[1]).toEqual({ kind: 'score_copy', dst: slot('r'), src: slot('a') });
+        expect(instrs[2]).toEqual({ kind: 'score_set', dst: { player: '$__const_7', obj: OBJ }, value: 7 });
+        expect(instrs[3]).toEqual({ kind: 'score_add', dst: slot('r'), src: { player: '$__const_7', obj: OBJ } });
+    });
+    test('sub, mul, div, mod all produce correct score ops', () => {
+        const ops = ['sub', 'mul', 'div', 'mod'];
+        const scoreOps = ['score_sub', 'score_mul', 'score_div', 'score_mod'];
+        for (let i = 0; i < ops.length; i++) {
+            const mod = mkModule([
+                mkFn('main', [
+                    mkBlock('entry', [
+                        { kind: 'const', dst: 'a', value: 10 },
+                        { kind: 'const', dst: 'b', value: 3 },
+                        { kind: ops[i], dst: 'r', a: t('a'), b: t('b') },
+                    ], { kind: 'return', value: null }),
+                ]),
+            ]);
+            const lir = (0, lower_1.lowerToLIR)(mod);
+            const main = lir.functions.find(f => f.name === 'main');
+            const instrs = main.instructions;
+            expect(instrs[2]).toEqual({ kind: 'score_copy', dst: slot('r'), src: slot('a') });
+            expect(instrs[3]).toEqual({ kind: scoreOps[i], dst: slot('r'), src: slot('b') });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Negation
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — negation', () => {
+    test('neg → score_set 0, score_sub', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'x', value: 5 },
+                    { kind: 'neg', dst: 'r', src: t('x') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // score_set $x 5
+        // score_set $r 0
+        // score_sub $r -= $x
+        expect(instrs[1]).toEqual({ kind: 'score_set', dst: slot('r'), value: 0 });
+        expect(instrs[2]).toEqual({ kind: 'score_sub', dst: slot('r'), src: slot('x') });
+    });
+});
+// ---------------------------------------------------------------------------
+// Comparison
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — comparison', () => {
+    test('cmp eq → score_set 0, raw execute if score', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'a', value: 1 },
+                    { kind: 'const', dst: 'b', value: 2 },
+                    { kind: 'cmp', dst: 'r', op: 'eq', a: t('a'), b: t('b') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // score_set $r 0, then raw execute if score
+        const setCmp = instrs.find(i => i.kind === 'score_set' && i.dst.player === '$main_r');
+        expect(setCmp).toEqual({ kind: 'score_set', dst: slot('r'), value: 0 });
+        const raw = instrs.find(i => i.kind === 'raw');
+        expect(raw).toBeDefined();
+        expect(raw.cmd).toContain('execute if score');
+        expect(raw.cmd).toContain('$main_a');
+        expect(raw.cmd).toContain('$main_b');
+        expect(raw.cmd).toContain('scoreboard players set $main_r');
+    });
+});
+// ---------------------------------------------------------------------------
+// Boolean logic
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — boolean logic', () => {
+    test('and → score_copy + score_mul', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'a', value: 1 },
+                    { kind: 'const', dst: 'b', value: 1 },
+                    { kind: 'and', dst: 'r', a: t('a'), b: t('b') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        expect(instrs[2]).toEqual({ kind: 'score_copy', dst: slot('r'), src: slot('a') });
+        expect(instrs[3]).toEqual({ kind: 'score_mul', dst: slot('r'), src: slot('b') });
+    });
+    test('not → score_set 1, score_sub', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'x', value: 1 },
+                    { kind: 'not', dst: 'r', src: t('x') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // score_set $x 1
+        // score_set $r 1
+        // score_sub $r -= $x
+        expect(instrs[1]).toEqual({ kind: 'score_set', dst: slot('r'), value: 1 });
+        expect(instrs[2]).toEqual({ kind: 'score_sub', dst: slot('r'), src: slot('x') });
+    });
+    test('or → score_copy + score_add + score_min(1)', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'a', value: 1 },
+                    { kind: 'const', dst: 'b', value: 0 },
+                    { kind: 'or', dst: 'r', a: t('a'), b: t('b') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // score_set $a 1, score_set $b 0
+        // score_copy $r = $a
+        // score_add $r += $b
+        // score_set $__const_1 1
+        // score_min $r, $__const_1
+        expect(instrs[2]).toEqual({ kind: 'score_copy', dst: slot('r'), src: slot('a') });
+        expect(instrs[3]).toEqual({ kind: 'score_add', dst: slot('r'), src: slot('b') });
+        const minInstr = instrs.find(i => i.kind === 'score_min');
+        expect(minInstr).toBeDefined();
+        expect(minInstr.dst).toEqual(slot('r'));
+    });
+});
+// ---------------------------------------------------------------------------
+// NBT operations
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — NBT', () => {
+    test('nbt_read → store_nbt_to_score', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'nbt_read', dst: 't0', ns: 'rs:data', path: 'val', scale: 1 },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[0]).toEqual({
+            kind: 'store_nbt_to_score',
+            dst: slot('t0'),
+            ns: 'rs:data',
+            path: 'val',
+            scale: 1,
+        });
+    });
+    test('nbt_write → store_score_to_nbt', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 10 },
+                    { kind: 'nbt_write', ns: 'rs:data', path: 'val', type: 'int', scale: 1, src: t('t0') },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[1]).toEqual({
+            kind: 'store_score_to_nbt',
+            ns: 'rs:data',
+            path: 'val',
+            type: 'int',
+            scale: 1,
+            src: slot('t0'),
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Function calls
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — calls', () => {
+    test('call with args → set $p0, $p1, call, copy $ret', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'a', value: 1 },
+                    { kind: 'const', dst: 'b', value: 2 },
+                    { kind: 'call', dst: 'r', fn: 'add', args: [t('a'), t('b')] },
+                ], { kind: 'return', value: null }),
+            ]),
+            mkFn('add', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // $p0 = $a
+        expect(instrs[2]).toEqual({
+            kind: 'score_copy',
+            dst: { player: '$p0', obj: OBJ },
+            src: slot('a'),
+        });
+        // $p1 = $b
+        expect(instrs[3]).toEqual({
+            kind: 'score_copy',
+            dst: { player: '$p1', obj: OBJ },
+            src: slot('b'),
+        });
+        // call test:add
+        expect(instrs[4]).toEqual({ kind: 'call', fn: 'test:add' });
+        // $r = $ret
+        expect(instrs[5]).toEqual({
+            kind: 'score_copy',
+            dst: slot('r'),
+            src: { player: '$ret', obj: OBJ },
+        });
+    });
+    test('call with no dst does not copy $ret', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'call', dst: null, fn: 'side_effect', args: [] },
+                ], { kind: 'return', value: null }),
+            ]),
+            mkFn('side_effect', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions).toEqual([
+            { kind: 'call', fn: 'test:side_effect' },
+        ]);
+    });
+    test('raw command via __raw: prefix', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'call', dst: null, fn: '__raw:say hello', args: [] },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[0]).toEqual({ kind: 'raw', cmd: 'say hello' });
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro calls
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — macro calls', () => {
+    test('call_macro → store args to NBT + call_macro', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'px', value: 100 },
+                    {
+                        kind: 'call_macro',
+                        dst: null,
+                        fn: 'draw_pt',
+                        args: [{ name: 'px', value: t('px'), type: 'int', scale: 1 }],
+                    },
+                ], { kind: 'return', value: null }),
+            ]),
+            mkFn('draw_pt', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ], [{ name: 'px', isMacroParam: true }], true),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const instrs = main.instructions;
+        // store_score_to_nbt for px
+        const storeNbt = instrs.find(i => i.kind === 'store_score_to_nbt');
+        expect(storeNbt).toBeDefined();
+        expect(storeNbt.ns).toBe('rs:macro_args');
+        expect(storeNbt.path).toBe('px');
+        // call_macro
+        const callMacro = instrs.find(i => i.kind === 'call_macro');
+        expect(callMacro).toBeDefined();
+        expect(callMacro.fn).toBe('test:draw_pt');
+        expect(callMacro.storage).toBe('rs:macro_args');
+    });
+});
+// ---------------------------------------------------------------------------
+// Context calls
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — context calls', () => {
+    test('call_context → call_context with qualified name', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    {
+                        kind: 'call_context',
+                        fn: 'helper',
+                        subcommands: [{ kind: 'as', selector: '@e[tag=foo]' }, { kind: 'at_self' }],
+                    },
+                ], { kind: 'return', value: null }),
+            ]),
+            mkFn('helper', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions[0]).toEqual({
+            kind: 'call_context',
+            fn: 'test:helper',
+            subcommands: [{ kind: 'as', selector: '@e[tag=foo]' }, { kind: 'at_self' }],
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Return
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — return', () => {
+    test('return with value → return_value', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 42 },
+                ], { kind: 'return', value: t('t0') }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        const ret = main.instructions.find(i => i.kind === 'return_value');
+        expect(ret).toBeDefined();
+        expect(ret.slot).toEqual(slot('t0'));
+    });
+    test('return void → no return_value instruction', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        expect(main.instructions.find(i => i.kind === 'return_value')).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Control flow — jump
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — jump (inlining)', () => {
+    test('jump to single-pred block inlines instructions', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 1 },
+                ], { kind: 'jump', target: 'next' }),
+                mkBlock('next', [
+                    { kind: 'const', dst: 't1', value: 2 },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        // Both blocks inlined: score_set t0, score_set t1
+        expect(main.instructions).toEqual([
+            { kind: 'score_set', dst: slot('t0'), value: 1 },
+            { kind: 'score_set', dst: slot('t1'), value: 2 },
+        ]);
+    });
+});
+// ---------------------------------------------------------------------------
+// Control flow — branch
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — branch', () => {
+    test('branch emits call_if_matches and call_unless_matches', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 'cond', value: 1 },
+                ], { kind: 'branch', cond: t('cond'), then: 'yes', else: 'no' }),
+                mkBlock('yes', [
+                    { kind: 'const', dst: 'a', value: 10 },
+                ], { kind: 'return', value: null }),
+                mkBlock('no', [
+                    { kind: 'const', dst: 'b', value: 20 },
+                ], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const main = lir.functions.find(f => f.name === 'main');
+        // Then-branch uses `return run function` (raw instruction) to prevent
+        // fallthrough when recursive calls clobber the condition slot.
+        const rawReturn = main.instructions.find(i => i.kind === 'raw' && i.cmd.includes('return run function'));
+        expect(rawReturn).toBeDefined();
+        expect(rawReturn.cmd).toContain('matches 1');
+        // Else-branch is an unconditional call (fallthrough only reached when cond≠1)
+        const elseCall = main.instructions.find(i => i.kind === 'call');
+        expect(elseCall).toBeDefined();
+        // The then/else blocks should be separate functions
+        const yesFn = lir.functions.find(f => f.name.includes('yes'));
+        const noFn = lir.functions.find(f => f.name.includes('no'));
+        expect(yesFn).toBeDefined();
+        expect(noFn).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Module structure
+// ---------------------------------------------------------------------------
+describe('MIR→LIR lowering — module', () => {
+    test('preserves namespace and objective', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ]),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        expect(lir.namespace).toBe(NS);
+        expect(lir.objective).toBe(OBJ);
+    });
+    test('macro function carries isMacro and macroParams', () => {
+        const mod = mkModule([
+            mkFn('draw', [
+                mkBlock('entry', [], { kind: 'return', value: null }),
+            ], [{ name: 'px', isMacroParam: true }, { name: 'py', isMacroParam: true }], true),
+        ]);
+        const lir = (0, lower_1.lowerToLIR)(mod);
+        const drawFn = lir.functions.find(f => f.name === 'draw');
+        expect(drawFn.isMacro).toBe(true);
+        expect(drawFn.macroParams).toEqual(['px', 'py']);
+    });
+});
+//# sourceMappingURL=lower.test.js.map

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

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