redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/mir/lower-extra5.test.ts

@@ -0,0 +1,612 @@
+/**
+ * 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)
+ */
+
+import { compile } from '../../emit/compile'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import type { MIRModule } from '../../mir/types'
+
+function compileMIR(source: string): MIRModule {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  const hir = lowerToHIR(ast)
+  return 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(() => 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(() => 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(() => 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(() => 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(() => 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(() => compile(`
+      fn f(e: Entity): int {
+        e.tag("vip");
+        return 0;
+      }
+    `, { namespace: 'etag' })).not.toThrow()
+  })
+
+  test('entity.untag("vip") compiles', () => {
+    expect(() => compile(`
+      fn f(e: Entity): int {
+        e.untag("vip");
+        return 0;
+      }
+    `, { namespace: 'euntag' })).not.toThrow()
+  })
+
+  test('entity.has_tag("vip") compiles', () => {
+    expect(() => 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(verifyMIR(mod)).toEqual([])
+  })
+
+  test('bool_to_str with 1 arg passes through', () => {
+    const mod = compileMIR(`
+      fn f(b: bool): int {
+        return b;
+      }
+    `)
+    expect(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(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(verifyMIR(mod)).toEqual([])
+  })
+})
+
+// ── static_call non-Timer ─────────────────────────────────────────────────
+
+describe('MIR lower — static_call non-Timer', () => {
+  test('Foo::create() static call emits generic call', () => {
+    expect(() => 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(() => 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(() => 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(() => 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: any) => f.name === 'magnitude')).toBeDefined()
+  })
+})
+
+// ── double param in function ──────────────────────────────────────────────
+
+describe('MIR lower — double param in function', () => {
+  test('function with double parameter uses NBT slot', () => {
+    expect(() => 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: any) => 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(() => 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(() => 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(() => 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(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(() => 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(() => 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(() => 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(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(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(verifyMIR(mod)).toEqual([])
+  })
+})
+
+// ── type_cast to double/fixed/int ────────────────────────────────────────
+
+describe('MIR lower — type_cast various targets', () => {
+  test('cast to int (no-op coercion)', () => {
+    expect(() => compile(`
+      fn f(n: float): int {
+        return n as int;
+      }
+    `, { namespace: 'castint' })).not.toThrow()
+  })
+
+  test('cast to fixed from non-double expr', () => {
+    expect(() => 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(() => compile(`
+      fn f(a: float, b: float): float {
+        return a * b;
+      }
+    `, { namespace: 'fmul' })).not.toThrow()
+  })
+
+  test('float / float emits scale correction', () => {
+    expect(() => 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(verifyMIR(mod)).toEqual([])
+  })
+
+  test('unary not', () => {
+    const mod = compileMIR(`
+      fn f(b: bool): bool {
+        return !b;
+      }
+    `)
+    expect(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(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(() => 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(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: any) => f.name === 'Vec2::scale')).toBeDefined()
+  })
+})