redscript-mc 1.0.0 → 1.2.0

package/dist/__tests__/lowering.test.js

@@ -77,6 +77,41 @@ fn test() -> int {
             const call = getInstructions(specialized).find(i => i.op === 'call');
             expect(call.fn).toBe('__lambda_0');
         });
+        it('lowers impl methods to prefixed function names', () => {
+            const ir = compile(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+`);
+            expect(getFunction(ir, 'Timer_elapsed')).toBeDefined();
+        });
+        it('lowers impl instance and static method calls', () => {
+            const ir = compile(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() -> int {
+  let timer: Timer = Timer::new(10);
+  return timer.elapsed();
+}
+`);
+            const fn = getFunction(ir, 'test');
+            const calls = getInstructions(fn).filter((instr) => instr.op === 'call');
+            expect(calls.map(call => call.fn)).toEqual(['Timer_new', 'Timer_elapsed']);
+        });
     });
     describe('let statements', () => {
         it('inlines const values without allocating scoreboard variables', () => {
@@ -204,6 +239,23 @@ fn test() -> int {
             const fn = getFunction(ir, 'foo');
             expect(fn.blocks.length).toBeGreaterThanOrEqual(3); // entry, then, else, merge
         });
+        it('lowers entity is-checks to execute if entity type filters', () => {
+            const ir = compile(`
+fn scan() {
+  foreach (e in @e) {
+    if (e is Player) {
+      kill(e);
+    }
+  }
+}
+`);
+            const foreachFn = ir.functions.find(fn => fn.name.includes('scan/foreach'));
+            const rawCmds = getRawCommands(foreachFn);
+            const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=player] run function test:scan/then_'));
+            expect(isCheckCmd).toBeDefined();
+            const thenFn = ir.functions.find(fn => fn.name.startsWith('scan/then_'));
+            expect(getRawCommands(thenFn)).toContain('kill @s');
+        });
     });
     describe('while statements', () => {
         it('creates loop structure', () => {
@@ -243,6 +295,31 @@ fn test() -> int {
             const rawCmds = getRawCommands(fn);
             expect(rawCmds.some(cmd => cmd.includes('data get storage rs:heap arr'))).toBe(true);
         });
+        it('lowers entity is-checks inside foreach bodies', () => {
+            const ir = compile(`
+fn test() {
+  foreach (e in @e) {
+    if (e is Player) {
+      give(@s, "diamond", 1);
+    }
+    if (e is Zombie) {
+      kill(@s);
+    }
+  }
+}
+`);
+            const mainFn = getFunction(ir, 'test');
+            const foreachFn = ir.functions.find(f => f.name === 'test/foreach_0');
+            const thenFns = ir.functions.filter(f => /^test\/then_/.test(f.name)).sort((a, b) => a.name.localeCompare(b.name));
+            const rawCmds = getRawCommands(foreachFn);
+            const [playerThenFn, zombieThenFn] = thenFns;
+            expect(getRawCommands(mainFn)).toContain('execute as @e run function test:test/foreach_0');
+            expect(thenFns).toHaveLength(2);
+            expect(rawCmds).toContain(`execute if entity @s[type=player] run function test:${playerThenFn.name}`);
+            expect(rawCmds).toContain(`execute if entity @s[type=zombie] run function test:${zombieThenFn.name}`);
+            expect(getRawCommands(playerThenFn).some(cmd => cmd.includes('give @s diamond 1'))).toBe(true);
+            expect(getRawCommands(zombieThenFn)).toContain('kill @s');
+        });
     });
     describe('match statements', () => {
         it('lowers match into guarded execute function calls', () => {
@@ -515,12 +592,12 @@ fn test() {
 `);
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('scoreboard objectives setdisplay sidebar kills');
-            expect(rawCmds).toContain('scoreboard objectives setdisplay list coins');
-            expect(rawCmds).toContain('scoreboard objectives setdisplay belowName hp');
+            expect(rawCmds).toContain('scoreboard objectives setdisplay sidebar test.kills');
+            expect(rawCmds).toContain('scoreboard objectives setdisplay list test.coins');
+            expect(rawCmds).toContain('scoreboard objectives setdisplay belowName test.hp');
             expect(rawCmds).toContain('scoreboard objectives setdisplay sidebar');
-            expect(rawCmds).toContain('scoreboard objectives add kills playerKillCount "Kill Count"');
-            expect(rawCmds).toContain('scoreboard objectives remove kills');
+            expect(rawCmds).toContain('scoreboard objectives add test.kills playerKillCount "Kill Count"');
+            expect(rawCmds).toContain('scoreboard objectives remove test.kills');
         });
         it('lowers bossbar management builtins', () => {
             const ir = compile(`
@@ -546,7 +623,7 @@ fn test() {
             expect(rawCmds).toContain('bossbar set ns:health visible true');
             expect(rawCmds).toContain('bossbar set ns:health players @a');
             expect(rawCmds).toContain('bossbar remove ns:health');
-            expect(rawCmds.some(cmd => /^execute store result score \$t\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true);
+            expect(rawCmds.some(cmd => /^execute store result score \$_\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true);
         });
         it('lowers team management builtins', () => {
             const ir = compile(`
@@ -574,13 +651,13 @@ fn test() {
             const ir = compile('fn test() { let x: int = random(1, 100); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('scoreboard players random $t0 rs 1 100');
+            expect(rawCmds).toContain('scoreboard players random $_0 rs 1 100');
         });
         it('lowers random_native()', () => {
             const ir = compile('fn test() { let x: int = random_native(1, 6); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('execute store result score $t0 rs run random value 1 6');
+            expect(rawCmds).toContain('execute store result score $_0 rs run random value 1 6');
         });
         it('lowers random_sequence()', () => {
             const ir = compile('fn test() { random_sequence("loot", 42); }');
@@ -588,6 +665,40 @@ fn test() {
             const rawCmds = getRawCommands(fn);
             expect(rawCmds).toContain('random reset loot 42');
         });
+        it('lowers setTimeout() to a scheduled helper function', () => {
+            const ir = compile('fn test() { setTimeout(100, () => { say("hi"); }); }');
+            const fn = getFunction(ir, 'test');
+            const timeoutFn = getFunction(ir, '__timeout_0');
+            const rawCmds = getRawCommands(fn);
+            const timeoutCmds = getRawCommands(timeoutFn);
+            expect(rawCmds).toContain('schedule function test:__timeout_0 100t');
+            expect(timeoutCmds).toContain('say hi');
+        });
+        it('lowers setInterval() to a self-rescheduling helper function', () => {
+            const ir = compile('fn test() { setInterval(20, () => { say("tick"); }); }');
+            const fn = getFunction(ir, 'test');
+            const intervalFn = getFunction(ir, '__interval_0');
+            const intervalBodyFn = getFunction(ir, '__interval_body_0');
+            const rawCmds = getRawCommands(fn);
+            const intervalCmds = getRawCommands(intervalFn);
+            const intervalBodyCmds = getRawCommands(intervalBodyFn);
+            expect(rawCmds).toContain('schedule function test:__interval_0 20t');
+            expect(intervalCmds).toContain('function test:__interval_body_0');
+            expect(intervalCmds).toContain('schedule function test:__interval_0 20t');
+            expect(intervalBodyCmds).toContain('say tick');
+        });
+        it('lowers clearInterval() to schedule clear for the generated interval function', () => {
+            const ir = compile(`
+fn test() {
+  let intervalId: int = setInterval(20, () => { say("tick"); });
+  clearInterval(intervalId);
+}
+`);
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('schedule function test:__interval_0 20t');
+            expect(rawCmds).toContain('schedule clear test:__interval_0');
+        });
         it('lowers data_get from entity', () => {
             const ir = compile('fn test() { let item_count: int = data_get("entity", "@s", "SelectedItem.Count"); }');
             const fn = getFunction(ir, 'test');
@@ -628,19 +739,25 @@ fn test() {
             const ir = compile('fn test() { let score: int = scoreboard_get(@s, "score"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s score'))).toBe(true);
+            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s test.score'))).toBe(true);
         });
         it('accepts bare selector targets in scoreboard_set', () => {
             const ir = compile('fn test() { scoreboard_set(@a, "kills", 0); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('scoreboard players set @a kills 0');
+            expect(rawCmds).toContain('scoreboard players set @a test.kills 0');
+        });
+        it('skips prefixing raw mc_name objectives', () => {
+            const ir = compile('fn test() { scoreboard_set(@s, #health, 100); }');
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('scoreboard players set @s health 100');
         });
         it('warns on quoted selectors in scoreboard_get', () => {
             const { ir, warnings } = compileWithWarnings('fn test() { let score: int = scoreboard_get("@s", "score"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s score'))).toBe(true);
+            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s test.score'))).toBe(true);
             expect(warnings).toContainEqual(expect.objectContaining({
                 code: 'W_QUOTED_SELECTOR',
                 message: 'Quoted selector "@s" is deprecated; pass @s without quotes',
@@ -650,7 +767,7 @@ fn test() {
             const { ir, warnings } = compileWithWarnings('fn test() { let total: int = scoreboard_get("#global", "total"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get #global total'))).toBe(true);
+            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get #global test.total'))).toBe(true);
             expect(warnings).toHaveLength(0);
         });
         it('warns on quoted selectors in data_get entity targets', () => {
@@ -663,6 +780,37 @@ fn test() {
                 message: 'Quoted selector "@s" is deprecated; pass @s without quotes',
             }));
         });
+        it('keeps already-qualified scoreboard objectives unchanged', () => {
+            const ir = compile('fn test() { scoreboard_set(@s, "custom.timer", 5); }');
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('scoreboard players set @s custom.timer 5');
+        });
+    });
+    describe('timer builtins', () => {
+        it('lowers timer builtins into schedule commands and wrapper functions', () => {
+            const ir = compile(`
+fn test() {
+  let intervalId: int = setInterval(20, () => {
+    say("tick");
+  });
+  setTimeout(100, () => {
+    say("later");
+  });
+  clearInterval(intervalId);
+}
+`);
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('schedule function test:__interval_0 20t');
+            expect(rawCmds).toContain('schedule function test:__timeout_0 100t');
+            expect(rawCmds).toContain('schedule clear test:__interval_0');
+            const intervalFn = getFunction(ir, '__interval_0');
+            expect(getRawCommands(intervalFn)).toEqual([
+                'function test:__interval_body_0',
+                'schedule function test:__interval_0 20t',
+            ]);
+        });
     });
     describe('decorators', () => {
         it('marks @tick function', () => {
@@ -681,6 +829,13 @@ fn test() {
             const fn = getFunction(ir, 'handle_advancement');
             expect(fn.eventTrigger).toEqual({ kind: 'advancement', value: 'story/mine_diamond' });
         });
+        it('marks @on event functions and binds player to @s', () => {
+            const ir = compile('@on(PlayerDeath) fn handle_death(player: Player) { tp(player, @p); }');
+            const fn = getFunction(ir, 'handle_death');
+            expect(fn.eventHandler).toEqual({ eventType: 'PlayerDeath', tag: 'rs.just_died' });
+            expect(fn.params).toEqual([]);
+            expect(getRawCommands(fn)).toContain('tp @s @p');
+        });
     });
     describe('selectors', () => {
         it('converts selector with filters to string', () => {
@@ -815,5 +970,38 @@ fn count_down() {
             expect(bodyBlock).toBeDefined();
         });
     });
+    describe('Global variables', () => {
+        it('registers global in IR globals with init value', () => {
+            const ir = compile('let x: int = 42;\nfn test() { say("hi"); }');
+            expect(ir.globals).toContainEqual({ name: '$x', init: 42 });
+        });
+        it('reads global variable in function body', () => {
+            const ir = compile('let count: int = 0;\nfn test() { let y: int = count; }');
+            const fn = getFunction(ir, 'test');
+            const instrs = getInstructions(fn);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$y' && i.src.kind === 'var' && i.src.name === '$count')).toBe(true);
+        });
+        it('writes global variable in function body', () => {
+            const ir = compile('let count: int = 0;\nfn inc() { count = 5; }');
+            const fn = getFunction(ir, 'inc');
+            const instrs = getInstructions(fn);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$count' && i.src.kind === 'const' && i.src.value === 5)).toBe(true);
+        });
+        it('compound assignment on global variable', () => {
+            const ir = compile('let count: int = 0;\nfn inc() { count += 1; }');
+            const fn = getFunction(ir, 'inc');
+            const instrs = getInstructions(fn);
+            expect(instrs.some(i => i.op === 'binop' && i.lhs.name === '$count' && i.bop === '+' && i.rhs.value === 1)).toBe(true);
+        });
+        it('const cannot be reassigned', () => {
+            const src = 'const X: int = 5;\nfn bad() { X = 10; }';
+            expect(() => compile(src)).toThrow(/Cannot assign to constant/);
+        });
+        it('multiple globals with different init values', () => {
+            const ir = compile('let a: int = 10;\nlet b: int = 20;\nfn test() { a = b; }');
+            expect(ir.globals).toContainEqual({ name: '$a', init: 10 });
+            expect(ir.globals).toContainEqual({ name: '$b', init: 20 });
+        });
+    });
 });
 //# sourceMappingURL=lowering.test.js.map