redscript-mc 2.4.1 → 2.6.0

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

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

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