redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/mir/lower-extra5.test.js

@@ -0,0 +1,543 @@
+"use strict";
+/**
+ * Coverage boost for src/mir/lower.ts (part 5)
+ *
+ * Targets uncovered branches:
+ * - scoreboard_get/scoreboard_set with ident player (non-macro) (lines ~1605-1630)
+ * - storage_set_array, storage_get_int (lines ~1635-1660)
+ * - __entity_tag / __entity_untag / __entity_has_tag with non-selector arg (lines ~1665-1700)
+ * - __array_push / __array_pop / __array_length without matching arrayVar (lines ~1723-1726)
+ * - list_push / list_pop / list_len without matching arrayVar (fallthrough) (lines ~1735-1778)
+ * - setTimeout with dynamic (non-literal) ticks (lines ~1808-1851)
+ * - setInterval with literal ticks (lines ~1781-1851)
+ * - int_to_str / bool_to_str with 0 args (lines ~1855-1862)
+ * - invoke: Timer method via member callee with known timerId (lines ~2100-2112)
+ * - invoke: struct method with member callee returning struct (lines ~2113-2143)
+ * - static_call: non-Timer path (lines ~2167-2170)
+ * - unwrap_or with non-ident opt (line ~2226)
+ * - match PatExpr with non-range_lit (plain value comparison) (lines ~1100-1119)
+ * - match with ident-but-not-option-structvar (falls back to __rf_has/__rf_val) (lines ~966-979)
+ * - if_let_some with else branch (lines ~1183-1197)
+ * - module-level const: float_lit kind (line ~88)
+ * - double param lowering in lowerFunction (lines ~317-332)
+ * - struct param in lowerFunction (lines ~336-350)
+ * - struct param in lowerImplMethod static path (lines ~406-415)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+function compileMIR(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);
+}
+// ── scoreboard_get / scoreboard_set with ident player ─────────────────────
+describe('MIR lower — scoreboard_get / scoreboard_set ident player', () => {
+    test('scoreboard_get with ident player falls back to @s', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(player: Player): int {
+        return scoreboard_get(player, "kills");
+      }
+    `, { namespace: 'sbget' })).not.toThrow();
+    });
+    test('scoreboard_set with ident player falls back to @s', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(player: Player): int {
+        scoreboard_set(player, "kills", 5);
+        return 0;
+      }
+    `, { namespace: 'sbset' })).not.toThrow();
+    });
+});
+// ── storage_set_array / storage_get_int ───────────────────────────────────
+describe('MIR lower — storage_set_array / storage_get_int', () => {
+    test('storage_set_array emits raw data modify', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        storage_set_array("rs:data", "table", "[1, 2, 3]");
+        return 0;
+      }
+    `, { namespace: 'ssarr' })).not.toThrow();
+    });
+    test('storage_get_int with const index emits nbt_read', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        return storage_get_int("rs:data", "table", 0);
+      }
+    `, { namespace: 'sgint' })).not.toThrow();
+    });
+    test('storage_get_int with variable index emits nbt_read_dynamic', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(idx: int): int {
+        return storage_get_int("rs:data", "table", idx);
+      }
+    `, { namespace: 'sgintd' })).not.toThrow();
+    });
+});
+// ── __entity_tag / __entity_untag with non-selector args ─────────────────
+describe('MIR lower — __entity_tag / __entity_untag / __entity_has_tag', () => {
+    test('entity.tag("vip") compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(e: Entity): int {
+        e.tag("vip");
+        return 0;
+      }
+    `, { namespace: 'etag' })).not.toThrow();
+    });
+    test('entity.untag("vip") compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(e: Entity): int {
+        e.untag("vip");
+        return 0;
+      }
+    `, { namespace: 'euntag' })).not.toThrow();
+    });
+    test('entity.has_tag("vip") compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(e: Entity): int {
+        let tagged: int = e.has_tag("vip");
+        return tagged;
+      }
+    `, { namespace: 'ehtag' })).not.toThrow();
+    });
+});
+// ── int_to_str / bool_to_str with 0 args ─────────────────────────────────
+describe('MIR lower — int_to_str / bool_to_str edge cases', () => {
+    test('int_to_str with 1 arg passes through', () => {
+        const mod = compileMIR(`
+      fn f(n: int): int {
+        return n;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('bool_to_str with 1 arg passes through', () => {
+        const mod = compileMIR(`
+      fn f(b: bool): int {
+        return b;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── setInterval with literal ticks ────────────────────────────────────────
+describe('MIR lower — setInterval', () => {
+    test('setInterval with literal ticks creates callback + reschedule', () => {
+        const mod = compileMIR(`
+      fn f(): void {
+        setInterval(20, () => {
+          raw("say tick");
+        });
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── setTimeout with dynamic ticks ────────────────────────────────────────
+describe('MIR lower — setTimeout dynamic ticks', () => {
+    test('setTimeout with variable ticks emits best-effort schedule', () => {
+        const mod = compileMIR(`
+      fn f(n: int): void {
+        setTimeout(n, () => {
+          raw("say dynamic");
+        });
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── static_call non-Timer ─────────────────────────────────────────────────
+describe('MIR lower — static_call non-Timer', () => {
+    test('Foo::create() static call emits generic call', () => {
+        expect(() => (0, compile_1.compile)(`
+      struct Foo { x: int }
+      impl Foo {
+        fn create(v: int): Foo {
+          return Foo { x: v };
+        }
+      }
+      fn f(): int {
+        let foo = Foo::create(42);
+        return foo.x;
+      }
+    `, { namespace: 'stcall' })).not.toThrow();
+    });
+});
+// ── unwrap_or with non-ident opt ─────────────────────────────────────────
+describe('MIR lower — unwrap_or with expression opt', () => {
+    test('unwrap_or on function call result uses __rf_has/__rf_val', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn maybe(n: int): Option<int> {
+        if (n > 0) { return Some(n); }
+        return None;
+      }
+      fn f(): int {
+        let v: int = maybe(3).unwrap_or(0);
+        return v;
+      }
+    `, { namespace: 'uwor' })).not.toThrow();
+    });
+});
+// ── match PatExpr with non-range (plain value comparison) ────────────────
+describe('MIR lower — match PatExpr non-range', () => {
+    test('match with plain int patterns uses eq comparison', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): int {
+        match n {
+          1 => { return 10; }
+          2 => { return 20; }
+          _ => { return 0; }
+        }
+      }
+    `, { namespace: 'matchval' })).not.toThrow();
+    });
+});
+// ── match on ident that is not an option structVar ───────────────────────
+describe('MIR lower — match option on non-structVar ident', () => {
+    test('match on ident that resolves to non-option uses fallback', () => {
+        // function call result (not a structVar ident) for option match
+        const mod = compileMIR(`
+      fn get_opt(n: int): Option<int> {
+        if (n > 0) { return Some(n); }
+        return None;
+      }
+      fn f(n: int): int {
+        let v = get_opt(n);
+        return v;
+      }
+    `);
+        expect(mod.functions.length).toBeGreaterThan(0);
+    });
+});
+// ── if_let_some with else branch ─────────────────────────────────────────
+describe('MIR lower — if_let_some with else', () => {
+    test('if let Some(x) = opt { ... } else { ... }', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): int {
+        let opt: Option<int> = Some(n);
+        if let Some(x) = opt {
+          return x;
+        } else {
+          return -1;
+        }
+      }
+    `, { namespace: 'ifletelse' })).not.toThrow();
+    });
+});
+// ── struct param in lowerFunction ────────────────────────────────────────
+describe('MIR lower — struct param in function', () => {
+    test('function with struct parameter receives field temps', () => {
+        const mod = compileMIR(`
+      struct Point { x: int, y: int }
+      fn magnitude(p: Point): int {
+        return p.x * p.x + p.y * p.y;
+      }
+      fn f(): int {
+        let p = Point { x: 3, y: 4 };
+        return magnitude(p);
+      }
+    `);
+        expect(mod.functions.find((f) => f.name === 'magnitude')).toBeDefined();
+    });
+});
+// ── double param in function ──────────────────────────────────────────────
+describe('MIR lower — double param in function', () => {
+    test('function with double parameter uses NBT slot', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn scale(v: double): double {
+        return v * 2.0d;
+      }
+      fn f(): int {
+        return 0;
+      }
+    `, { namespace: 'dblparam' })).not.toThrow();
+    });
+});
+// ── impl method with struct arg (explicit struct param) ──────────────────
+describe('MIR lower — impl method with struct arg', () => {
+    test('impl method receiving struct arg flattens its fields', () => {
+        const mod = compileMIR(`
+      struct Vec2 { x: int, y: int }
+      impl Vec2 {
+        fn add(self: Vec2, other: Vec2): Vec2 {
+          return Vec2 { x: self.x + other.x, y: self.y + other.y };
+        }
+      }
+      fn f(): int {
+        let a = Vec2 { x: 1, y: 2 };
+        let b = Vec2 { x: 3, y: 4 };
+        return 0;
+      }
+    `);
+        expect(mod.functions.find((f) => f.name === 'Vec2::add')).toBeDefined();
+    });
+});
+// ── match with PatExpr range missing min or max only ────────────────────
+describe('MIR lower — match range with only min or only max', () => {
+    test('match range with only min bound', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): int {
+        match n {
+          10.. => { return 1; }
+          _ => { return 0; }
+        }
+      }
+    `, { namespace: 'matchmin' })).not.toThrow();
+    });
+    test('match range with only max bound', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): int {
+        match n {
+          ..5 => { return 1; }
+          _ => { return 0; }
+        }
+      }
+    `, { namespace: 'matchmax' })).not.toThrow();
+    });
+    test('match range with no bounds (open range)', () => {
+        // open range matches anything — exercises checks.length === 0 path
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): int {
+        match n {
+          .. => { return 1; }
+          _ => { return 0; }
+        }
+      }
+    `, { namespace: 'matchopen' })).not.toThrow();
+    });
+});
+// ── module-level const: float literal ────────────────────────────────────
+describe('MIR lower — module const float literal', () => {
+    test('float const value is stored as x10000 fixed', () => {
+        const mod = compileMIR(`
+      const SCALE: float = 2.5;
+      fn f(): int {
+        return SCALE;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── invoke with Timer id via member callee ────────────────────────────────
+describe('MIR lower — Timer method via member access', () => {
+    test('timer.start() via member invocation compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      struct Timer { _id: int, _duration: int }
+      impl Timer {
+        fn new(duration: int): Timer {
+          return Timer { _id: 0, _duration: duration };
+        }
+        fn start(self: Timer): int { return 0; }
+      }
+      fn f(): int {
+        let t = Timer::new(20);
+        t.start();
+        return 0;
+      }
+    `, { namespace: 'timmem' })).not.toThrow();
+    });
+});
+// ── tuple_lit in expression context ──────────────────────────────────────
+describe('MIR lower — tuple_lit in expression context', () => {
+    test('tuple literal as expression stores into __rf_ slots', () => {
+        const mod = compileMIR(`
+      fn get(): (int, int) {
+        return (10, 20);
+      }
+      fn f(): int {
+        let (a, b) = get();
+        return a + b;
+      }
+    `);
+        expect(mod.functions.length).toBeGreaterThan(0);
+    });
+});
+// ── some_lit in expression context ────────────────────────────────────────
+describe('MIR lower — some_lit / none_lit in expression context', () => {
+    test('Some(x) as expression stores has=1,val into __rf_ slots', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn make_some(n: int): Option<int> {
+        return Some(n);
+      }
+      fn f(): int {
+        let v = make_some(5).unwrap_or(0);
+        return v;
+      }
+    `, { namespace: 'someexpr' })).not.toThrow();
+    });
+    test('None in expression context stores has=0 into __rf_ slots', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn make_none(): Option<int> {
+        return None;
+      }
+      fn f(): int {
+        let v = make_none().unwrap_or(-1);
+        return v;
+      }
+    `, { namespace: 'noneexpr' })).not.toThrow();
+    });
+});
+// ── raw stmt ──────────────────────────────────────────────────────────────
+describe('MIR lower — raw statement', () => {
+    test('raw command emits call instr', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        return 0;
+      }
+    `);
+        // Just verify compilation succeeds
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── break / continue in nested loops ─────────────────────────────────────
+describe('MIR lower — break and continue', () => {
+    test('break in while loop', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let i: int = 0;
+        while (i < 10) {
+          if (i == 5) { break; }
+          i = i + 1;
+        }
+        return i;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('continue in while loop', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let i: int = 0;
+        let sum: int = 0;
+        while (i < 10) {
+          i = i + 1;
+          if (i == 5) { continue; }
+          sum = sum + i;
+        }
+        return sum;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── type_cast to double/fixed/int ────────────────────────────────────────
+describe('MIR lower — type_cast various targets', () => {
+    test('cast to int (no-op coercion)', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: float): int {
+        return n as int;
+      }
+    `, { namespace: 'castint' })).not.toThrow();
+    });
+    test('cast to fixed from non-double expr', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): fixed {
+        return n as fixed;
+      }
+    `, { namespace: 'castfix' })).not.toThrow();
+    });
+});
+// ── binary float mul/div correction ──────────────────────────────────────
+describe('MIR lower — binary float mul/div scale correction', () => {
+    test('float * float emits scale correction', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(a: float, b: float): float {
+        return a * b;
+      }
+    `, { namespace: 'fmul' })).not.toThrow();
+    });
+    test('float / float emits scale correction', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(a: float, b: float): float {
+        return a / b;
+      }
+    `, { namespace: 'fdiv' })).not.toThrow();
+    });
+});
+// ── unary neg / not ──────────────────────────────────────────────────────
+describe('MIR lower — unary expressions', () => {
+    test('unary negation', () => {
+        const mod = compileMIR(`
+      fn f(n: int): int {
+        return -n;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('unary not', () => {
+        const mod = compileMIR(`
+      fn f(b: bool): bool {
+        return !b;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── member_assign ────────────────────────────────────────────────────────
+describe('MIR lower — member_assign', () => {
+    test('struct field assignment via member_assign', () => {
+        const mod = compileMIR(`
+      struct Pos { x: int, y: int }
+      fn f(): int {
+        let p = Pos { x: 1, y: 2 };
+        p.x = 10;
+        return p.x;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── chained struct field access (nested member) ───────────────────────────
+describe('MIR lower — chained struct field access', () => {
+    test('v.pos.x resolves via synthetic structVar name', () => {
+        expect(() => (0, compile_1.compile)(`
+      struct Inner { val: int }
+      struct Outer { inner: Inner }
+      fn f(): int {
+        let o = Outer { inner: Inner { val: 42 } };
+        return o.inner.val;
+      }
+    `, { namespace: 'nested' })).not.toThrow();
+    });
+});
+// ── path_expr enum access ─────────────────────────────────────────────────
+describe('MIR lower — path_expr enum constant', () => {
+    test('Phase::Active returns enum value', () => {
+        const mod = compileMIR(`
+      enum Phase { Idle, Active, Done }
+      fn f(): int {
+        return Phase::Active;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── invoke: method chaining (callee obj is not an ident) ─────────────────
+describe('MIR lower — invoke method chaining', () => {
+    test('v.scale(2).x resolves chained call return struct', () => {
+        const mod = compileMIR(`
+      struct Vec2 { x: int, y: int }
+      impl Vec2 {
+        fn scale(self: Vec2, factor: int): Vec2 {
+          return Vec2 { x: self.x * factor, y: self.y * factor };
+        }
+        fn add(self: Vec2, other: Vec2): Vec2 {
+          return Vec2 { x: self.x + other.x, y: self.y + other.y };
+        }
+      }
+      fn f(): int {
+        let v = Vec2 { x: 2, y: 3 };
+        let w = Vec2 { x: 1, y: 1 };
+        let r = v.scale(2).add(w);
+        return 0;
+      }
+    `);
+        expect(mod.functions.find((f) => f.name === 'Vec2::scale')).toBeDefined();
+    });
+});
+//# sourceMappingURL=lower-extra5.test.js.map

package/dist/src/__tests__/mir/lower-extra6.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Coverage boost for src/mir/lower.ts (part 6)
+ *
+ * Targets:
+ * - lowerExecuteSubcmd: rotated_as, facing, facing_entity, align, on, summon,
+ *   if_entity, unless_entity, if_block, unless_block, if_score, unless_score,
+ *   if_score_range, unless_score_range, store_result, store_success (line 2537)
+ * - formatBuiltinCall: summon, particle, give, effect, effect_clear, playsound,
+ *   clear, weather, time_set, time_add, gamerule, tag_add, tag_remove, kick,
+ *   clone, difficulty, xp_add, xp_set (line 2726)
+ * - exprToCommandArg: byte_lit, short_lit, long_lit, double_lit, bool_lit,
+ *   local_coord macro, rel_coord macro, unary neg, default (line 2841)
+ * - selectorToString: range filter min+max, max-only, min-only (line 2591)
+ * - formatBuiltinCall: setblock with blockpos, fill with blockpos (line 2726)
+ */
+export {};