redscript-mc 2.5.0 → 2.6.0

package/dist/__tests__/lowering.test.js

@@ -1,1015 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lexer_1 = require("../lexer");
-const parser_1 = require("../parser");
-const lowering_1 = require("../lowering");
-function compile(source, namespace = 'test') {
-    return compileWithWarnings(source, namespace).ir;
-}
-function compileWithWarnings(source, namespace = 'test') {
-    const tokens = new lexer_1.Lexer(source).tokenize();
-    const ast = new parser_1.Parser(tokens).parse(namespace);
-    const lowering = new lowering_1.Lowering(namespace);
-    return { ir: lowering.lower(ast), warnings: lowering.warnings };
-}
-function getFunction(module, name) {
-    return module.functions.find(f => f.name === name);
-}
-function getInstructions(fn) {
-    return fn.blocks.flatMap(b => b.instrs);
-}
-function getRawCommands(fn) {
-    return getInstructions(fn)
-        .filter((i) => i.op === 'raw')
-        .map(i => i.cmd);
-}
-describe('Lowering', () => {
-    describe('basic functions', () => {
-        it('lowers empty function', () => {
-            const ir = compile('fn empty() {}');
-            const fn = getFunction(ir, 'empty');
-            expect(fn).toBeDefined();
-            expect(fn?.blocks).toHaveLength(1);
-            expect(fn?.blocks[0].term.op).toBe('return');
-        });
-        it('lowers function with params', () => {
-            const ir = compile('fn add(a: int, b: int) -> int { return a + b; }');
-            const fn = getFunction(ir, 'add');
-            expect(fn).toBeDefined();
-            expect(fn?.params).toEqual(['$a', '$b']);
-        });
-        it('creates param copy instructions', () => {
-            const ir = compile('fn foo(x: int) {}');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$foo_x' && i.src.kind === 'param' && i.src.index === 0)).toBe(true);
-        });
-        it('fills in missing default arguments at call sites', () => {
-            const ir = compile(`
-fn damage(amount: int, multiplier: int = 1) -> int {
-  return amount * multiplier;
-}
-
-fn test() -> int {
-  return damage(10);
-}
-`);
-            const fn = getFunction(ir, 'test');
-            const call = getInstructions(fn).find(i => i.op === 'call');
-            expect(call.args).toHaveLength(2);
-            expect(call.args[0]).toEqual({ kind: 'const', value: 10 });
-            expect(call.args[1]).toEqual({ kind: 'const', value: 1 });
-        });
-        it('specializes callback-accepting functions for lambda arguments', () => {
-            const ir = compile(`
-fn apply(val: int, cb: (int) -> int) -> int {
-  return cb(val);
-}
-
-fn test() -> int {
-  return apply(5, (x: int) => x * 3);
-}
-`);
-            expect(getFunction(ir, '__lambda_0')).toBeDefined();
-            const specialized = ir.functions.find(fn => fn.name.startsWith('apply__cb___lambda_0'));
-            expect(specialized).toBeDefined();
-            expect(specialized?.params).toEqual(['$val']);
-            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', () => {
-            const ir = compile(`
-const MAX_HP: int = 100
-
-fn foo() {
-  let x: int = MAX_HP;
-}
-`);
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$foo_x' && i.src.kind === 'const' && i.src.value === 100)).toBe(true);
-            expect(ir.globals).not.toContain('$MAX_HP');
-        });
-        it('lowers let with literal', () => {
-            const ir = compile('fn foo() { let x: int = 42; }');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$foo_x' && i.src.value === 42)).toBe(true);
-        });
-        it('lowers let with expression', () => {
-            const ir = compile('fn foo(a: int) { let x: int = a + 1; }');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'binop')).toBe(true);
-        });
-        it('stores literal-backed string variables in storage for str_len', () => {
-            const ir = compile('fn foo() { let name: string = "Player"; let n: int = str_len(name); }');
-            const fn = getFunction(ir, 'foo');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('data modify storage rs:strings name set value "Player"');
-            expect(rawCmds.some(cmd => cmd.includes('execute store result score') && cmd.includes('run data get storage rs:strings name'))).toBe(true);
-        });
-    });
-    describe('return statements', () => {
-        it('lowers return with value', () => {
-            const ir = compile('fn foo() -> int { return 42; }');
-            const fn = getFunction(ir, 'foo');
-            const term = fn.blocks[0].term;
-            expect(term.op).toBe('return');
-            expect(term.value).toEqual({ kind: 'const', value: 42 });
-        });
-        it('lowers empty return', () => {
-            const ir = compile('fn foo() { return; }');
-            const fn = getFunction(ir, 'foo');
-            const term = fn.blocks[0].term;
-            expect(term.op).toBe('return');
-            expect(term.value).toBeUndefined();
-        });
-    });
-    describe('lambda lowering', () => {
-        it('lowers lambda variables to generated sub-functions', () => {
-            const ir = compile(`
-fn test() {
-  let double: (int) -> int = (x: int) => x * 2;
-  let result: int = double(5);
-}
-`);
-            const lambdaFn = getFunction(ir, '__lambda_0');
-            expect(lambdaFn).toBeDefined();
-            const testFn = getFunction(ir, 'test');
-            const calls = getInstructions(testFn).filter((instr) => instr.op === 'call');
-            expect(calls.some(call => call.fn === '__lambda_0')).toBe(true);
-        });
-        it('inlines immediately-invoked expression-body lambdas', () => {
-            const ir = compile(`
-fn test() -> int {
-  return ((x: int) => x * 2)(5);
-}
-`);
-            expect(ir.functions.find(fn => fn.name.startsWith('__lambda_'))).toBeUndefined();
-            const testFn = getFunction(ir, 'test');
-            expect(getInstructions(testFn).some(instr => instr.op === 'binop')).toBe(true);
-        });
-    });
-    describe('binary expressions', () => {
-        it('lowers arithmetic', () => {
-            const ir = compile('fn foo(a: int, b: int) -> int { return a + b; }');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            const binop = instrs.find(i => i.op === 'binop');
-            expect(binop).toBeDefined();
-            expect(binop.bop).toBe('+');
-        });
-        it('lowers comparison', () => {
-            const ir = compile('fn foo(a: int, b: int) -> bool { return a < b; }');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            const cmp = instrs.find(i => i.op === 'cmp');
-            expect(cmp).toBeDefined();
-            expect(cmp.cop).toBe('<');
-        });
-    });
-    describe('unary expressions', () => {
-        it('lowers negation', () => {
-            const ir = compile('fn foo(x: int) -> int { return -x; }');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            const binop = instrs.find(i => i.op === 'binop' && i.bop === '-');
-            expect(binop).toBeDefined();
-            // -x is lowered as 0 - x
-            expect(binop.lhs).toEqual({ kind: 'const', value: 0 });
-        });
-        it('lowers logical not', () => {
-            const ir = compile('fn foo(x: bool) -> bool { return !x; }');
-            const fn = getFunction(ir, 'foo');
-            const instrs = getInstructions(fn);
-            const cmp = instrs.find(i => i.op === 'cmp' && i.cop === '==');
-            expect(cmp).toBeDefined();
-            // !x is lowered as x == 0
-            expect(cmp.rhs).toEqual({ kind: 'const', value: 0 });
-        });
-    });
-    describe('if statements', () => {
-        it('creates conditional jump', () => {
-            const ir = compile('fn foo(x: int) { if (x > 0) { let y: int = 1; } }');
-            const fn = getFunction(ir, 'foo');
-            expect(fn.blocks.length).toBeGreaterThan(1);
-            const term = fn.blocks[0].term;
-            expect(term.op).toBe('jump_if');
-        });
-        it('creates else block', () => {
-            const ir = compile('fn foo(x: int) { if (x > 0) { let y: int = 1; } else { let y: int = 2; } }');
-            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=minecraft: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', () => {
-            const ir = compile('fn foo() { let i: int = 0; while (i < 10) { i = i + 1; } }');
-            const fn = getFunction(ir, 'foo');
-            // Should have: entry -> check -> body -> exit
-            expect(fn.blocks.length).toBeGreaterThanOrEqual(3);
-            // Find loop_check block
-            const checkBlock = fn.blocks.find(b => b.label.includes('loop_check'));
-            expect(checkBlock).toBeDefined();
-        });
-    });
-    describe('foreach statements', () => {
-        it('extracts body into sub-function', () => {
-            const ir = compile('fn kill_all() { foreach (e in @e[type=zombie]) { kill(e); } }');
-            expect(ir.functions.length).toBe(2); // main + foreach sub-function
-            const subFn = ir.functions.find(f => f.name.includes('foreach'));
-            expect(subFn).toBeDefined();
-        });
-        it('emits execute as ... run function', () => {
-            const ir = compile('fn kill_all() { foreach (e in @e[type=zombie]) { kill(e); } }');
-            const mainFn = getFunction(ir, 'kill_all');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute as @e[type=minecraft:zombie]') && cmd.includes('run function'))).toBe(true);
-        });
-        it('binding maps to @s in sub-function', () => {
-            const ir = compile('fn kill_all() { foreach (e in @e[type=zombie]) { kill(e); } }');
-            const subFn = ir.functions.find(f => f.name.includes('foreach'));
-            const rawCmds = getRawCommands(subFn);
-            expect(rawCmds.some(cmd => cmd === 'kill @s')).toBe(true);
-        });
-        it('lowers foreach over array into a counting loop', () => {
-            const ir = compile('fn walk() { let arr: int[] = [1, 2, 3]; foreach (x in arr) { let y: int = x; } }');
-            const fn = getFunction(ir, 'walk');
-            expect(fn.blocks.some(b => b.label.includes('foreach_array_check'))).toBe(true);
-            expect(fn.blocks.some(b => b.label.includes('foreach_array_body'))).toBe(true);
-            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=minecraft:player] run function test:${playerThenFn.name}`);
-            expect(rawCmds).toContain(`execute if entity @s[type=minecraft: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', () => {
-            const ir = compile('fn choose() { let choice: int = 2; match (choice) { 1 => { say("one"); } 2 => { say("two"); } _ => { say("other"); } } }');
-            const fn = getFunction(ir, 'choose');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('execute if score') && cmd.includes('matches 1 run function'))).toBe(true);
-            expect(rawCmds.some(cmd => cmd.includes('execute if score') && cmd.includes('matches 2 run function'))).toBe(true);
-            expect(rawCmds.some(cmd => cmd.includes('matches ..0 run function'))).toBe(true);
-            expect(ir.functions.filter(f => f.name.includes('match_')).length).toBe(3);
-        });
-        it('lowers enum variants to integer constants in comparisons and match arms', () => {
-            const ir = compile(`
-enum Direction { North, South, East, West }
-
-fn choose(dir: Direction) {
-  if (dir == Direction.South) {
-    say("south");
-  }
-  match (dir) {
-    Direction.North => { say("north"); }
-    Direction.South => { say("south"); }
-    _ => { say("other"); }
-  }
-}
-`);
-            const fn = getFunction(ir, 'choose');
-            const rawCmds = getRawCommands(fn);
-            expect(getInstructions(fn).some(i => i.op === 'cmp' && i.rhs.value === 1)).toBe(true);
-            expect(rawCmds.some(cmd => cmd.includes('matches 0 run function'))).toBe(true);
-            expect(rawCmds.some(cmd => cmd.includes('matches 1 run function'))).toBe(true);
-        });
-    });
-    describe('arrays', () => {
-        it('lowers array literal initialization', () => {
-            const ir = compile('fn test() { let arr: int[] = [1, 2, 3]; }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('data modify storage rs:heap arr set value []');
-            expect(rawCmds).toContain('data modify storage rs:heap arr append value 1');
-            expect(rawCmds).toContain('data modify storage rs:heap arr append value 2');
-            expect(rawCmds).toContain('data modify storage rs:heap arr append value 3');
-        });
-        it('lowers array len property', () => {
-            const ir = compile('fn test() { let arr: int[] = [1]; let n: int = arr.len; }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('execute store result score') && cmd.includes('run data get storage rs:heap arr'))).toBe(true);
-        });
-        it('lowers static array indexing', () => {
-            const ir = compile('fn test() { let arr: int[] = [7, 8]; let x: int = arr[0]; }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run data get storage rs:heap arr[0]'))).toBe(true);
-        });
-        it('lowers dynamic array indexing via macro helper', () => {
-            const ir = compile('fn test() { let arr: int[] = [7, 8]; let i: int = 1; let x: int = arr[i]; }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('with storage rs:heap'))).toBe(true);
-            const helperFn = ir.functions.find(f => f.name.includes('array_get_'));
-            expect(helperFn).toBeDefined();
-            expect(getRawCommands(helperFn).some(cmd => cmd.includes('arr[$('))).toBe(true);
-        });
-        it('lowers array push', () => {
-            const ir = compile('fn test() { let arr: int[] = []; arr.push(4); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('data modify storage rs:heap arr append value 4');
-        });
-        it('lowers array pop', () => {
-            const ir = compile('fn test() { let arr: int[] = [1, 2]; let x: int = arr.pop(); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run data get storage rs:heap arr[-1]'))).toBe(true);
-            expect(rawCmds).toContain('data remove storage rs:heap arr[-1]');
-        });
-    });
-    describe('as/at blocks', () => {
-        it('extracts as block into sub-function', () => {
-            const ir = compile('fn test() { as @a { say("hello"); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute as @a') && cmd.includes('run function'))).toBe(true);
-        });
-        it('extracts at block into sub-function', () => {
-            const ir = compile('fn test() { at @s { summon("zombie"); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute at @s') && cmd.includes('run function'))).toBe(true);
-        });
-    });
-    describe('execute inline blocks', () => {
-        it('extracts execute as run block into sub-function', () => {
-            const ir = compile('fn test() { execute as @a run { say("hello from each"); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute as @a run function'))).toBe(true);
-        });
-        it('extracts execute as at run block into sub-function', () => {
-            const ir = compile('fn test() { execute as @a at @s run { particle("flame"); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute as @a at @s run function'))).toBe(true);
-        });
-        it('handles execute with if entity condition', () => {
-            const ir = compile('fn test() { execute as @a if entity @s[tag=admin] run { give(@s, "diamond", 1); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute as @a if entity @s[tag=admin] run function'))).toBe(true);
-        });
-        it('handles execute with unless entity condition', () => {
-            const ir = compile('fn test() { execute as @a unless entity @s[tag=dead] run { effect(@s, "regeneration", 5); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute as @a unless entity @s[tag=dead] run function'))).toBe(true);
-        });
-        it('handles execute with in dimension', () => {
-            const ir = compile('fn test() { execute in the_nether run { say("in nether"); } }');
-            expect(ir.functions.length).toBe(2);
-            const mainFn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(mainFn);
-            expect(rawCmds.some(cmd => cmd.includes('execute in the_nether run function'))).toBe(true);
-        });
-        it('lowered sub-function contains body commands', () => {
-            const ir = compile('fn test() { execute as @a run { say("inner"); give(@s, "bread", 1); } }');
-            const subFn = ir.functions.find(f => f.name.includes('exec_'));
-            expect(subFn).toBeDefined();
-            const rawCmds = getRawCommands(subFn);
-            expect(rawCmds).toContain('say inner');
-            expect(rawCmds.some(cmd => cmd.includes('give @s bread 1'))).toBe(true);
-        });
-    });
-    describe('builtins', () => {
-        it('lowers say()', () => {
-            const ir = compile('fn test() { say("hello"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('say hello');
-        });
-        it('lowers kill()', () => {
-            const ir = compile('fn test() { kill(@e[type=zombie]); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('kill @e[type=minecraft:zombie]');
-        });
-        it('lowers give()', () => {
-            const ir = compile('fn test() { give(@p, "diamond", 64); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('give @p diamond 64');
-        });
-        it('lowers actionbar(), subtitle(), and title_times()', () => {
-            const ir = compile('fn test() { actionbar(@a, "Fight!"); subtitle(@a, "Next wave"); title_times(@a, 10, 40, 10); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('title @a actionbar {"text":"Fight!"}');
-            expect(rawCmds).toContain('title @a subtitle {"text":"Next wave"}');
-            expect(rawCmds).toContain('title @a times 10 40 10');
-        });
-        it('lowers announce()', () => {
-            const ir = compile('fn test() { announce("Server event starting"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tellraw @a {"text":"Server event starting"}');
-        });
-        it('lowers interpolated say() to tellraw score components', () => {
-            const ir = compile('fn test() { let score: int = 7; say("You have ${score} points"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$test_score","objective":"rs"}},{"text":" points"}]');
-        });
-        it('lowers f-string output builtins to tellraw/title JSON components', () => {
-            const ir = compile('fn test() { let score: int = 7; say(f"Score: {score}"); tellraw(@a, f"Score: {score}"); actionbar(@s, f"Score: {score}"); title(@s, f"Score: {score}"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]');
-            expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]');
-            expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]');
-        });
-        it('lowers summon()', () => {
-            const ir = compile('fn test() { summon("zombie"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('summon zombie'))).toBe(true);
-        });
-        it('lowers effect()', () => {
-            const ir = compile('fn test() { effect(@a, "speed", 30, 1); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('effect give @a speed 30 1'))).toBe(true);
-        });
-        it('lowers tp() for both positions and entity destinations', () => {
-            const ir = compile('fn test() { tp(@s, (~1, ~0, ~-1)); tp(@s, "^0", "^1", "^0"); tp(@s, @p); tp(@a, (1, 64, 1)); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tp @s ~1 ~ ~-1');
-            expect(rawCmds).toContain('tp @s ^0 ^1 ^0');
-            expect(rawCmds).toContain('tp @s @p');
-            expect(rawCmds).toContain('tp @a 1 64 1');
-        });
-        it('warns when using tp_to()', () => {
-            const { ir, warnings } = compileWithWarnings('fn test() { tp_to(@s, @p); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tp @s @p');
-            expect(warnings).toContainEqual(expect.objectContaining({
-                code: 'W_DEPRECATED',
-                message: 'tp_to is deprecated; use tp instead',
-            }));
-        });
-        it('lowers inventory and player admin commands', () => {
-            const ir = compile('fn test() { clear(@s); clear(@s, "minecraft:stick"); kick(@p); kick(@p, "AFK"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('clear @s');
-            expect(rawCmds).toContain('clear @s minecraft:stick');
-            expect(rawCmds).toContain('kick @p');
-            expect(rawCmds).toContain('kick @p AFK');
-        });
-        it('lowers world management commands', () => {
-            const ir = compile('fn test() { weather("rain"); time_set("day"); time_add(1000); gamerule("doDaylightCycle", "false"); difficulty("hard"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('weather rain');
-            expect(rawCmds).toContain('time set day');
-            expect(rawCmds).toContain('time add 1000');
-            expect(rawCmds).toContain('gamerule doDaylightCycle false');
-            expect(rawCmds).toContain('difficulty hard');
-        });
-        it('lowers tag_add() and tag_remove()', () => {
-            const ir = compile('fn test() { tag_add(@s, "boss"); tag_remove(@s, "boss"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tag @s add boss');
-            expect(rawCmds).toContain('tag @s remove boss');
-        });
-        it('lowers setblock(), fill(), and clone()', () => {
-            const ir = compile('fn test() { setblock((4, 65, 4), "stone"); fill((0, 64, 0), (8, 64, 8), "minecraft:smooth_stone"); clone((0, 64, 0), (4, 68, 4), (10, 64, 10)); setblock("~", "~", "~", "legacy"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('setblock 4 65 4 stone');
-            expect(rawCmds).toContain('fill 0 64 0 8 64 8 minecraft:smooth_stone');
-            expect(rawCmds).toContain('clone 0 64 0 4 68 4 10 64 10');
-            expect(rawCmds).toContain('setblock ~ ~ ~ legacy');
-        });
-        it('lowers BlockPos locals in coordinate builtins', () => {
-            const ir = compile('fn test() { let spawn: BlockPos = (4, 65, 4); setblock(spawn, "minecraft:stone"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('setblock 4 65 4 minecraft:stone');
-        });
-        it('lowers xp_add() and xp_set()', () => {
-            const ir = compile('fn test() { xp_add(@s, 5); xp_add(@s, 2, "levels"); xp_set(@s, 0); xp_set(@s, 3, "levels"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('xp add @s 5 points');
-            expect(rawCmds).toContain('xp add @s 2 levels');
-            expect(rawCmds).toContain('xp set @s 0 points');
-            expect(rawCmds).toContain('xp set @s 3 levels');
-        });
-        it('lowers scoreboard display and objective management builtins', () => {
-            const ir = compile(`
-fn test() {
-  scoreboard_display("sidebar", "kills");
-  scoreboard_display("list", "coins");
-  scoreboard_display("belowName", "hp");
-  scoreboard_hide("sidebar");
-  scoreboard_add_objective("kills", "playerKillCount", "Kill Count");
-  scoreboard_remove_objective("kills");
-}
-`);
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            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 test.kills playerKillCount "Kill Count"');
-            expect(rawCmds).toContain('scoreboard objectives remove test.kills');
-        });
-        it('lowers bossbar management builtins', () => {
-            const ir = compile(`
-fn test() {
-  bossbar_add("ns:health", "Boss Health");
-  bossbar_set_value("ns:health", 50);
-  bossbar_set_max("ns:health", 100);
-  bossbar_set_color("ns:health", "red");
-  bossbar_set_style("ns:health", "notched_10");
-  bossbar_set_visible("ns:health", true);
-  bossbar_set_players("ns:health", @a);
-  bossbar_remove("ns:health");
-  let current: int = bossbar_get_value("ns:health");
-}
-`);
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('bossbar add ns:health {"text":"Boss Health"}');
-            expect(rawCmds).toContain('bossbar set ns:health value 50');
-            expect(rawCmds).toContain('bossbar set ns:health max 100');
-            expect(rawCmds).toContain('bossbar set ns:health color red');
-            expect(rawCmds).toContain('bossbar set ns:health style notched_10');
-            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 \$_\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true);
-        });
-        it('lowers team management builtins', () => {
-            const ir = compile(`
-fn test() {
-  team_add("red", "Red Team");
-  team_remove("red");
-  team_join("red", @a[tag=red_team]);
-  team_leave(@s);
-  team_option("red", "friendlyFire", "false");
-  team_option("red", "color", "red");
-  team_option("red", "prefix", "[Red] ");
-}
-`);
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('team add red {"text":"Red Team"}');
-            expect(rawCmds).toContain('team remove red');
-            expect(rawCmds).toContain('team join red @a[tag=red_team]');
-            expect(rawCmds).toContain('team leave @s');
-            expect(rawCmds).toContain('team modify red friendlyFire false');
-            expect(rawCmds).toContain('team modify red color red');
-            expect(rawCmds).toContain('team modify red prefix {"text":"[Red] "}');
-        });
-        it('lowers random()', () => {
-            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 $_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 $_0 rs run random value 1 6');
-        });
-        it('lowers random_sequence()', () => {
-            const ir = compile('fn test() { random_sequence("loot", 42); }');
-            const fn = getFunction(ir, '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');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('execute store result score') &&
-                cmd.includes('run data get entity @s SelectedItem.Count 1'))).toBe(true);
-        });
-        it('lowers data_get from block', () => {
-            const ir = compile('fn test() { let furnace_fuel: int = data_get("block", "~ ~ ~", "BurnTime"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run data get block ~ ~ ~ BurnTime 1'))).toBe(true);
-        });
-        it('lowers data_get from storage', () => {
-            const ir = compile('fn test() { let val: int = data_get("storage", "mypack:globals", "player_count"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run data get storage mypack:globals player_count 1'))).toBe(true);
-        });
-        it('lowers data_get with scale factor', () => {
-            const ir = compile('fn test() { let scaled: int = data_get("entity", "@s", "Pos[0]", "1000"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run data get entity @s Pos[0] 1000'))).toBe(true);
-        });
-        it('data_get result can be used in expressions', () => {
-            const ir = compile(`
-        fn test() {
-          let count: int = data_get("entity", "@s", "SelectedItem.Count");
-          let doubled: int = count * 2;
-        }
-      `);
-            const fn = getFunction(ir, 'test');
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'binop' && i.bop === '*')).toBe(true);
-        });
-        it('accepts bare selector targets in scoreboard_get', () => {
-            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 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 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 test.score'))).toBe(true);
-            expect(warnings).toContainEqual(expect.objectContaining({
-                code: 'W_QUOTED_SELECTOR',
-                message: 'Quoted selector "@s" is deprecated; pass @s without quotes',
-            }));
-        });
-        it('does not warn on fake player names', () => {
-            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 test.total'))).toBe(true);
-            expect(warnings).toHaveLength(0);
-        });
-        it('warns on quoted selectors in data_get entity targets', () => {
-            const { ir, warnings } = compileWithWarnings('fn test() { let pos: int = data_get("entity", "@s", "Pos[0]"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run data get entity @s Pos[0] 1'))).toBe(true);
-            expect(warnings).toContainEqual(expect.objectContaining({
-                code: 'W_QUOTED_SELECTOR',
-                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', () => {
-            const ir = compile('@tick fn game_loop() {}');
-            const fn = getFunction(ir, 'game_loop');
-            expect(fn.isTickLoop).toBe(true);
-        });
-        it('marks @on_trigger function', () => {
-            const ir = compile('@on_trigger("my_trigger") fn handle_trigger() {}');
-            const fn = getFunction(ir, 'handle_trigger');
-            expect(fn.isTriggerHandler).toBe(true);
-            expect(fn.triggerName).toBe('my_trigger');
-        });
-        it('marks @on_advancement function for advancement json generation', () => {
-            const ir = compile('@on_advancement("story/mine_diamond") fn handle_advancement() {}');
-            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', () => {
-            const ir = compile('fn test() { kill(@e[type=zombie, distance=..10, tag=boss]); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            const killCmd = rawCmds.find(cmd => cmd.startsWith('kill'));
-            expect(killCmd).toContain('type=minecraft:zombie');
-            expect(killCmd).toContain('distance=..10');
-            expect(killCmd).toContain('tag=boss');
-        });
-        it('warns and auto-qualifies unnamespaced entity types', () => {
-            const { ir, warnings } = compileWithWarnings('fn test() { kill(@e[type=zombie]); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('kill @e[type=minecraft:zombie]');
-            expect(warnings).toContainEqual({
-                code: 'W_UNNAMESPACED_TYPE',
-                message: 'Unnamespaced entity type "zombie", auto-qualifying to "minecraft:zombie"',
-            });
-        });
-        it('passes through minecraft entity types without warnings', () => {
-            const { ir, warnings } = compileWithWarnings('fn test() { kill(@e[type=minecraft:zombie]); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('kill @e[type=minecraft:zombie]');
-            expect(warnings).toHaveLength(0);
-        });
-        it('passes through custom namespaced entity types without warnings', () => {
-            const { ir, warnings } = compileWithWarnings('fn test() { kill(@e[type=my_mod:custom_mob]); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('kill @e[type=my_mod:custom_mob]');
-            expect(warnings).toHaveLength(0);
-        });
-        it('throws on invalid entity type format', () => {
-            expect(() => compileWithWarnings('fn test() { kill(@e[type=invalid!!!]); }'))
-                .toThrow('Invalid entity type format: "invalid!!!"');
-        });
-    });
-    describe('raw commands', () => {
-        it('passes through raw commands', () => {
-            const ir = compile('fn test() { raw("tp @a ~ ~10 ~"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tp @a ~ ~10 ~');
-        });
-    });
-    describe('assignment operators', () => {
-        it('lowers compound assignment', () => {
-            const ir = compile('fn test() { let x: int = 5; x += 3; }');
-            const fn = getFunction(ir, 'test');
-            const instrs = getInstructions(fn);
-            const binop = instrs.find(i => i.op === 'binop' && i.bop === '+');
-            expect(binop).toBeDefined();
-        });
-    });
-    describe('entity tag methods', () => {
-        it('lowers entity.tag()', () => {
-            const ir = compile('fn test() { @s.tag("boss"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tag @s add boss');
-        });
-        it('lowers entity.untag()', () => {
-            const ir = compile('fn test() { @s.untag("boss"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tag @s remove boss');
-        });
-        it('lowers entity.has_tag() and returns temp var', () => {
-            const ir = compile('fn test() { let x: bool = @s.has_tag("boss"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('execute store result score') && cmd.includes('if entity @s[tag=boss]'))).toBe(true);
-        });
-        it('lowers entity.tag() on selector with filters', () => {
-            const ir = compile('fn test() { @e[type=zombie].tag("marked"); }');
-            const fn = getFunction(ir, 'test');
-            const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('tag @e[type=minecraft:zombie] add marked'))).toBe(true);
-        });
-    });
-    describe('complex programs', () => {
-        it('compiles add function correctly', () => {
-            const source = `
-fn add(a: int, b: int) -> int {
-    return a + b;
-}
-`;
-            const ir = compile(source);
-            const fn = getFunction(ir, 'add');
-            expect(fn.params).toEqual(['$a', '$b']);
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'binop' && i.bop === '+')).toBe(true);
-            const term = fn.blocks[fn.blocks.length - 1].term;
-            expect(term.op).toBe('return');
-            expect(term.value?.kind).toBe('var');
-        });
-        it('compiles abs function with if/else', () => {
-            const source = `
-fn abs(x: int) -> int {
-    if (x < 0) {
-        return -x;
-    } else {
-        return x;
-    }
-}
-`;
-            const ir = compile(source);
-            const fn = getFunction(ir, 'abs');
-            expect(fn.blocks.length).toBeGreaterThanOrEqual(3);
-            // Should have comparison
-            const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'cmp' && i.cop === '<')).toBe(true);
-        });
-        it('compiles countdown with while', () => {
-            const source = `
-fn count_down() {
-    let i: int = 10;
-    while (i > 0) {
-        i = i - 1;
-    }
-}
-`;
-            const ir = compile(source);
-            const fn = getFunction(ir, 'count_down');
-            // Should have loop structure
-            const checkBlock = fn.blocks.find(b => b.label.includes('loop_check'));
-            const bodyBlock = fn.blocks.find(b => b.label.includes('loop_body'));
-            expect(checkBlock).toBeDefined();
-            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 === '$test_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