redscript-mc 2.6.2 → 3.0.0

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

@@ -0,0 +1,471 @@
+"use strict";
+/**
+ * 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)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+// ── execute subcommand variants ────────────────────────────────────────────
+describe('MIR lower — execute subcommand: rotated_as', () => {
+    test('rotated as @s compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute rotated as @s run {
+          tell(@s, "rotated");
+        }
+        return 0;
+      }
+    `, { namespace: 'exrot' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: facing', () => {
+    test('facing coordinates compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute facing ~ ~1 ~ run {
+          tell(@s, "facing");
+        }
+        return 0;
+      }
+    `, { namespace: 'exfac' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: facing entity', () => {
+    test('facing entity @s eyes compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute facing entity @s eyes run {
+          tell(@s, "facing entity");
+        }
+        return 0;
+      }
+    `, { namespace: 'exface' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: align', () => {
+    test('align xyz compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute align xyz run {
+          tell(@s, "aligned");
+        }
+        return 0;
+      }
+    `, { namespace: 'exalign' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: on', () => {
+    test('on attacker compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute on attacker run {
+          tell(@s, "on attacker");
+        }
+        return 0;
+      }
+    `, { namespace: 'exon' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: summon', () => {
+    test('execute summon entity compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute summon zombie run {
+          tell(@s, "summon");
+        }
+        return 0;
+      }
+    `, { namespace: 'exsum' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: positioned_as', () => {
+    test('positioned as @s compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute positioned as @s run {
+          tell(@s, "positioned_as");
+        }
+        return 0;
+      }
+    `, { namespace: 'expas' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: if/unless entity', () => {
+    test('if entity @e compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute if entity @e run {
+          tell(@s, "if entity");
+        }
+        return 0;
+      }
+    `, { namespace: 'exife' })).not.toThrow();
+    });
+    test('unless entity @e compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute unless entity @e run {
+          tell(@s, "unless entity");
+        }
+        return 0;
+      }
+    `, { namespace: 'exunlesse' })).not.toThrow();
+    });
+});
+describe('MIR lower — execute subcommand: if/unless block', () => {
+    test('if block position compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute if block ~ ~ ~ stone run {
+          tell(@s, "if block");
+        }
+        return 0;
+      }
+    `, { namespace: 'exifb' })).not.toThrow();
+    });
+    test('unless block position compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute unless block ~ ~ ~ stone run {
+          tell(@s, "unless block");
+        }
+        return 0;
+      }
+    `, { namespace: 'exunlessb' })).not.toThrow();
+    });
+});
+// ── formatBuiltinCall variants ─────────────────────────────────────────────
+describe('MIR lower — builtin: summon', () => {
+    test('summon entity compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        summon("zombie", "~", "~", "~");
+        return 0;
+      }
+    `, { namespace: 'bisum' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: particle', () => {
+    test('particle with coords compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        particle("minecraft:heart", "~", "~", "~");
+        return 0;
+      }
+    `, { namespace: 'biprt' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: give', () => {
+    test('give item compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        give(@s, "minecraft:diamond", "1");
+        return 0;
+      }
+    `, { namespace: 'bigive' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: effect', () => {
+    test('effect give compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        effect(@s, "speed", "30", "0");
+        return 0;
+      }
+    `, { namespace: 'bieff' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: effect_clear', () => {
+    test('effect clear single effect compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        effect_clear(@s, "speed");
+        return 0;
+      }
+    `, { namespace: 'bieffc' })).not.toThrow();
+    });
+    test('effect clear all effects compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        effect_clear(@s);
+        return 0;
+      }
+    `, { namespace: 'bieffca' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: playsound', () => {
+    test('playsound compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        playsound("entity.player.levelup", "master", @s);
+        return 0;
+      }
+    `, { namespace: 'bipsnd' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: clear', () => {
+    test('clear inventory compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        clear(@s, "minecraft:dirt");
+        return 0;
+      }
+    `, { namespace: 'biclr' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: weather', () => {
+    test('weather clear compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        weather("clear");
+        return 0;
+      }
+    `, { namespace: 'biwth' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: time_set / time_add', () => {
+    test('time_set compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        time_set("day");
+        return 0;
+      }
+    `, { namespace: 'bitset' })).not.toThrow();
+    });
+    test('time_add compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        time_add("1000");
+        return 0;
+      }
+    `, { namespace: 'bitadd' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: gamerule', () => {
+    test('gamerule compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        gamerule("keepInventory", "true");
+        return 0;
+      }
+    `, { namespace: 'bigr' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: tag_add / tag_remove', () => {
+    test('tag_add compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        tag_add(@s, "my_tag");
+        return 0;
+      }
+    `, { namespace: 'bitag' })).not.toThrow();
+    });
+    test('tag_remove compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        tag_remove(@s, "my_tag");
+        return 0;
+      }
+    `, { namespace: 'bitagr' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: kick', () => {
+    test('kick player compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        kick(@s, "bye");
+        return 0;
+      }
+    `, { namespace: 'bikick' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: clone', () => {
+    test('clone blocks compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        clone("0", "0", "0", "10", "10", "10", "20", "20", "20");
+        return 0;
+      }
+    `, { namespace: 'biclone' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: difficulty', () => {
+    test('difficulty compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        difficulty("hard");
+        return 0;
+      }
+    `, { namespace: 'bidiff' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: xp_add / xp_set', () => {
+    test('xp_add compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        xp_add(@s, "10");
+        return 0;
+      }
+    `, { namespace: 'bixpa' })).not.toThrow();
+    });
+    test('xp_set compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        xp_set(@s, "10", "points");
+        return 0;
+      }
+    `, { namespace: 'bixps' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: kill', () => {
+    test('kill with selector compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        kill(@s);
+        return 0;
+      }
+    `, { namespace: 'bikill' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: setblock with blockpos', () => {
+    test('setblock with blockpos tuple compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        setblock((1, 2, 3), "stone");
+        return 0;
+      }
+    `, { namespace: 'bisbp' })).not.toThrow();
+    });
+});
+describe('MIR lower — builtin: fill with blockpos', () => {
+    test('fill with blockpos tuples compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        fill((0, 0, 0), (10, 10, 10), "stone");
+        return 0;
+      }
+    `, { namespace: 'bifill' })).not.toThrow();
+    });
+});
+// ── selectorToString with range filters ───────────────────────────────────
+describe('MIR lower — selectorToString range filter', () => {
+    test('selector with level min..max range filter', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute as @a[level=1..10] run {
+          tell(@s, "range");
+        }
+        return 0;
+      }
+    `, { namespace: 'selrng' })).not.toThrow();
+    });
+    test('selector with level max-only range filter', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute as @a[level=..5] run {
+          tell(@s, "max only");
+        }
+        return 0;
+      }
+    `, { namespace: 'selmx' })).not.toThrow();
+    });
+    test('selector with level min-only range filter', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute as @a[level=5..] run {
+          tell(@s, "min only");
+        }
+        return 0;
+      }
+    `, { namespace: 'selmn' })).not.toThrow();
+    });
+});
+// ── exprToCommandArg edge cases ────────────────────────────────────────────
+describe('MIR lower — exprToCommandArg: various literal types', () => {
+    test('bool literal in command arg', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        gamerule("keepInventory", true);
+        return 0;
+      }
+    `, { namespace: 'argbool' })).not.toThrow();
+    });
+    test('float literal in summon arg', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        summon("zombie", "~", "~", "~");
+        return 0;
+      }
+    `, { namespace: 'argflt' })).not.toThrow();
+    });
+});
+// ── fill without blockpos (plain coords) ──────────────────────────────────
+describe('MIR lower — fill without blockpos', () => {
+    test('fill with plain string coords compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        fill("0", "0", "0", "10", "10", "10", "stone");
+        return 0;
+      }
+    `, { namespace: 'fillno' })).not.toThrow();
+    });
+});
+// ── say builtin ────────────────────────────────────────────────────────────
+describe('MIR lower — builtin: say', () => {
+    test('say compiles to say command', () => {
+        const result = (0, compile_1.compile)(`
+      fn f(): int {
+        say("hello world");
+        return 0;
+      }
+    `, { namespace: 'bigsay' });
+        const fn = result.files.find(f => f.path.includes('f.mcfunction'));
+        expect(fn?.content).toContain('say hello world');
+    });
+});
+// ── title_times builtin ────────────────────────────────────────────────────
+describe('MIR lower — builtin: title_times', () => {
+    test('title_times compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        title_times(@s, "10", "70", "20");
+        return 0;
+      }
+    `, { namespace: 'bitt' })).not.toThrow();
+    });
+});
+// ── if_score / unless_score execute subcommands ───────────────────────────
+describe('MIR lower — execute: if_score / unless_score subcommands', () => {
+    test('execute if score compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute if score myvar __test = othervar __test run {
+          tell(@s, "equal");
+        }
+        return 0;
+      }
+    `, { namespace: 'exifs' })).not.toThrow();
+    });
+    test('execute unless score compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        execute unless score myvar __test = othervar __test run {
+          tell(@s, "not equal");
+        }
+        return 0;
+      }
+    `, { namespace: 'exunlss' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=lower-extra6.test.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * Coverage boost for src/mir/lower.ts (part 7)
+ *
+ * Targets uncovered branches across many areas:
+ * - module-level const with bool_lit and float_lit (line 40, 88)
+ * - lowerFunction string param handling (lines 320-330)
+ * - let with type annotation format_string (line 545)
+ * - let with struct literal containing nested struct (lines 576-591)
+ * - let_destruct with ident referencing known tupleVar (line 736)
+ * - let_destruct with general expression (lines 757-763)
+ * - return with struct_lit (lines 789-793)
+ * - return with tuple_lit (lines 794-798)
+ * - return with ident option struct (lines 799-804)
+ * - while_let_some with non-option sv (lines 1295-1316)
+ * - double_lit expr case (lines 1371-1376)
+ * - byte_lit/short_lit/long_lit handled (lines 1365-1368)
+ * - struct_lit in expr context (lines 1378-1386)
+ * - type_cast to 'int' with double var (lines 2415-2425)
+ * - type_cast to other types (lines 2430-2435)
+ * - type_cast to fixed/float with non-double inner (lines 2426-2431)
+ * - fstring with non-ident/non-lit expr parts (precomputeFStringParts complex path)
+ * - announce with f-string (line 2963)
+ * - title/subtitle/actionbar with f-string (lines 2940-2962)
+ * - give with 4th nbt arg (line 2968)
+ * - xp_add with third arg (line 2993)
+ * - exprToCommandArg: float_lit, double_lit (lines 2900-2906)
+ * - hirExprToStringLiteral: default branch (line 3060)
+ * - match with PatEnum arm (enum payload pattern)
+ * - match with PatExpr range arm (min+max, min-only, max-only)
+ * - invoke.callee.obj.kind !== 'ident' (method chain, lines 2241-2262)
+ * - let with type option, non-some/none/struct_lit init (lines 601-608)
+ * - do-while / repeat loops
+ * - @coroutine / @inline / @profile / @deprecated / @watch / @config / @singleton decorators
+ */
+export {};