redscript-mc 2.4.0 → 2.4.1

package/dist/src/__tests__/macro.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for MC 1.20.2+ macro function support
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), RedScript should
+ * automatically compile it as a macro function using $-prefixed syntax.
+ */
+export {};

package/dist/src/__tests__/macro.test.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * Tests for MC 1.20.2+ macro function support
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), RedScript should
+ * automatically compile it as a macro function using $-prefixed syntax.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lowering_1 = require("../lowering");
+const mcfunction_1 = require("../codegen/mcfunction");
+function compile(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 lowering.lower(ast);
+}
+function getFunction(module, name) {
+    return module.functions.find(f => f.name === name);
+}
+function getRawCommands(fn) {
+    return fn.blocks
+        .flatMap(b => b.instrs)
+        .filter((i) => i.op === 'raw')
+        // \x01 is the sentinel for the MC macro line-start '$'; normalize for test assertions
+        .map(i => i.cmd.replace(/^\x01/, '$'));
+}
+function getGeneratedContent(module, fnName) {
+    const files = (0, mcfunction_1.generateDatapack)(module);
+    const file = files.find(f => f.path.includes(`/${fnName}.mcfunction`));
+    return file?.content;
+}
+// ---------------------------------------------------------------------------
+// Macro function detection
+// ---------------------------------------------------------------------------
+describe('MC macro function detection', () => {
+    it('marks function as macro when int param used in summon coordinates', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'spawn_zombie');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+        expect(fn.macroParamNames).toEqual(expect.arrayContaining(['x', 'y', 'z']));
+    });
+    it('does NOT mark function as macro when all summon args are constants', () => {
+        const ir = compile(`
+fn spawn_fixed() {
+    summon("minecraft:zombie", 100, 64, 200);
+}
+`);
+        const fn = getFunction(ir, 'spawn_fixed');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBeFalsy();
+    });
+    it('marks function as macro when int param used in particle coordinates', () => {
+        const ir = compile(`
+fn show_particle(x: int, y: int, z: int) {
+    particle("minecraft:flame", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'show_particle');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+    });
+    it('marks function as macro when int param used in setblock coordinates', () => {
+        const ir = compile(`
+fn place_block(x: int, y: int, z: int) {
+    setblock(x, y, z, "minecraft:stone");
+}
+`);
+        const fn = getFunction(ir, 'place_block');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+        expect(fn.macroParamNames).toEqual(expect.arrayContaining(['x', 'y', 'z']));
+    });
+    it('identifies only the params used in macro positions', () => {
+        const ir = compile(`
+fn do_stuff(count: int, x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+    // count is not used in a macro position
+}
+`);
+        const fn = getFunction(ir, 'do_stuff');
+        expect(fn).toBeDefined();
+        expect(fn.isMacroFunction).toBe(true);
+        // x, y, z should be macro params; count should NOT be
+        expect(fn.macroParamNames).toEqual(expect.arrayContaining(['x', 'y', 'z']));
+        expect(fn.macroParamNames).not.toContain('count');
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro command generation in function body
+// ---------------------------------------------------------------------------
+describe('MC macro command generation', () => {
+    it('generates $-prefixed summon command with $(param) for macro params', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'spawn_zombie');
+        const cmds = getRawCommands(fn);
+        // Should have a macro command for summon
+        const macroCmd = cmds.find(c => c.startsWith('$summon'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+        expect(macroCmd).toContain('$(y)');
+        expect(macroCmd).toContain('$(z)');
+        expect(macroCmd).toBe('$summon minecraft:zombie $(x) $(y) $(z)');
+    });
+    it('generates non-prefixed command when args are literals', () => {
+        const ir = compile(`
+fn spawn_fixed() {
+    summon("minecraft:zombie", 100, 64, 200);
+}
+`);
+        const fn = getFunction(ir, 'spawn_fixed');
+        const cmds = getRawCommands(fn);
+        const summonCmd = cmds.find(c => c.includes('summon'));
+        expect(summonCmd).toBeDefined();
+        expect(summonCmd.startsWith('$')).toBe(false);
+        expect(summonCmd).toContain('100');
+        expect(summonCmd).toContain('64');
+        expect(summonCmd).toContain('200');
+    });
+    it('generates $-prefixed particle command with $(param)', () => {
+        const ir = compile(`
+fn show_particle(x: int, y: int, z: int) {
+    particle("minecraft:flame", x, y, z);
+}
+`);
+        const fn = getFunction(ir, 'show_particle');
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$particle'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+    });
+    it('generates $-prefixed setblock command with $(param)', () => {
+        const ir = compile(`
+fn place_block(x: int, y: int, z: int) {
+    setblock(x, y, z, "minecraft:stone");
+}
+`);
+        const fn = getFunction(ir, 'place_block');
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$setblock'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+        expect(macroCmd).toContain('$(y)');
+        expect(macroCmd).toContain('$(z)');
+        expect(macroCmd).toContain('minecraft:stone');
+    });
+});
+// ---------------------------------------------------------------------------
+// Call site code generation
+// ---------------------------------------------------------------------------
+describe('MC macro call site generation', () => {
+    it('emits NBT setup + with-storage call for variable args', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+
+fn caller(px: int, pz: int) {
+    spawn_zombie(px, 64, pz);
+}
+`);
+        const callerFn = getFunction(ir, 'caller');
+        const cmds = getRawCommands(callerFn);
+        // Should have NBT setup for variable params (px → x, pz → z)
+        const xSetup = cmds.find(c => c.includes('macro_args') && c.includes(' x '));
+        const zSetup = cmds.find(c => c.includes('macro_args') && c.includes(' z '));
+        expect(xSetup).toBeDefined();
+        expect(zSetup).toBeDefined();
+        // Should have 'function test:spawn_zombie with storage rs:macro_args'
+        const callCmd = cmds.find(c => c.includes('spawn_zombie') && c.includes('with storage'));
+        expect(callCmd).toBeDefined();
+        expect(callCmd).toContain('rs:macro_args');
+    });
+    it('emits NBT setup for constant args too', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+
+fn caller_const() {
+    spawn_zombie(100, 64, 200);
+}
+`);
+        const callerFn = getFunction(ir, 'caller_const');
+        const cmds = getRawCommands(callerFn);
+        // Should have NBT setup for all macro params
+        const nbtCmds = cmds.filter(c => c.includes('macro_args'));
+        expect(nbtCmds.length).toBeGreaterThan(0);
+        // Should call with storage
+        const callCmd = cmds.find(c => c.includes('spawn_zombie') && c.includes('with storage'));
+        expect(callCmd).toBeDefined();
+    });
+    it('correctly sets up int variable args into NBT storage', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+
+fn caller(my_x: int) {
+    spawn_zombie(my_x, 64, 0);
+}
+`);
+        const callerFn = getFunction(ir, 'caller');
+        const cmds = getRawCommands(callerFn);
+        // For variable arg my_x → x: should use execute store result
+        const varSetup = cmds.find(c => c.includes('execute store result storage rs:macro_args x') &&
+            c.includes('scoreboard players get'));
+        expect(varSetup).toBeDefined();
+        // For constant 64 → y: should use data modify ... set value
+        const constSetup = cmds.find(c => c.includes('data modify storage rs:macro_args y set value 64'));
+        expect(constSetup).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Codegen output (mcfunction file content)
+// ---------------------------------------------------------------------------
+describe('MC macro function codegen output', () => {
+    it('generates $-prefixed lines in the macro function mcfunction file', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+`);
+        const content = getGeneratedContent(ir, 'spawn_zombie');
+        expect(content).toBeDefined();
+        expect(content).toContain('$summon minecraft:zombie $(x) $(y) $(z)');
+    });
+    it('generates correct call site in caller mcfunction file', () => {
+        const ir = compile(`
+fn spawn_zombie(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+}
+
+fn caller(px: int, pz: int) {
+    spawn_zombie(px, 64, pz);
+}
+`);
+        const content = getGeneratedContent(ir, 'caller');
+        expect(content).toBeDefined();
+        expect(content).toContain('with storage rs:macro_args');
+        expect(content).toContain('spawn_zombie');
+    });
+});
+// ---------------------------------------------------------------------------
+// Edge cases
+// ---------------------------------------------------------------------------
+describe('MC macro edge cases', () => {
+    it('handles mixed literal and variable args correctly', () => {
+        const ir = compile(`
+fn teleport_y(y: int) {
+    summon("minecraft:zombie", 100, y, 200);
+}
+`);
+        const fn = getFunction(ir, 'teleport_y');
+        expect(fn.isMacroFunction).toBe(true);
+        expect(fn.macroParamNames).toContain('y');
+        expect(fn.macroParamNames).not.toContain('x');
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$summon'));
+        expect(macroCmd).toBeDefined();
+        // x and z are literals, y is macro
+        expect(macroCmd).toContain('100');
+        expect(macroCmd).toContain('$(y)');
+        expect(macroCmd).toContain('200');
+    });
+    it('non-macro functions still work normally', () => {
+        const ir = compile(`
+fn greet() {
+    say("hello world");
+}
+`);
+        const fn = getFunction(ir, 'greet');
+        expect(fn.isMacroFunction).toBeFalsy();
+        const cmds = getRawCommands(fn);
+        const sayCmd = cmds.find(c => c.includes('say') || c.includes('tellraw'));
+        expect(sayCmd).toBeDefined();
+        expect(sayCmd.startsWith('$')).toBe(false);
+    });
+    it('macro function with params used in arithmetic still works', () => {
+        const ir = compile(`
+fn spawn_offset(x: int, y: int, z: int) {
+    summon("minecraft:zombie", x, y, z);
+    // params are also used in the macro commands
+}
+`);
+        const fn = getFunction(ir, 'spawn_offset');
+        expect(fn.isMacroFunction).toBe(true);
+        // The macro commands should use $(param) syntax
+        const cmds = getRawCommands(fn);
+        const macroCmd = cmds.find(c => c.startsWith('$summon'));
+        expect(macroCmd).toBeDefined();
+        expect(macroCmd).toContain('$(x)');
+    });
+});
+//# sourceMappingURL=macro.test.js.map

package/dist/src/__tests__/nbt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/nbt.test.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const structure_1 = require("../codegen/structure");
+const nbt_1 = require("../nbt");
+describe('NBT codec', () => {
+    test('round-trips a compound tag', () => {
+        const tag = nbt_1.nbt.compound({ x: nbt_1.nbt.int(42), name: nbt_1.nbt.string('test') });
+        const buf = (0, nbt_1.writeNbt)(tag, 'root');
+        const parsed = (0, nbt_1.readNbt)(buf);
+        expect(parsed.name).toBe('root');
+        expect(parsed.tag).toEqual(tag);
+    });
+    test('round-trips nested lists and arrays', () => {
+        const tag = nbt_1.nbt.compound({
+            nested: nbt_1.nbt.list(10 /* TagType.Compound */, [
+                nbt_1.nbt.compound({ values: nbt_1.nbt.intArray([1, 2, 3]) }),
+                nbt_1.nbt.compound({ bytes: nbt_1.nbt.byteArray([-1, 0, 1]) }),
+            ]),
+            longs: { type: 12 /* TagType.LongArray */, value: BigInt64Array.from([1n, 2n, 3n]) },
+        });
+        const buf = (0, nbt_1.writeNbt)(tag, 'root');
+        const parsed = (0, nbt_1.readNbt)(buf);
+        expect(parsed.tag).toEqual(tag);
+    });
+    test('handles longs correctly', () => {
+        const tag = nbt_1.nbt.compound({ ts: nbt_1.nbt.long(9007199254740993n) });
+        const buf = (0, nbt_1.writeNbt)(tag, '');
+        const parsed = (0, nbt_1.readNbt)(buf);
+        const root = parsed.tag;
+        expect(root.entries.get('ts')).toEqual(nbt_1.nbt.long(9007199254740993n));
+        expect(root.entries.get('ts').value).toBe(9007199254740993n);
+    });
+});
+describe('Structure generator', () => {
+    test('compiles counter.mcrs to a non-empty structure', () => {
+        const filePath = 'src/examples/counter.mcrs';
+        const src = fs.readFileSync(filePath, 'utf-8');
+        const { buffer, blockCount } = (0, structure_1.compileToStructure)(src, 'counter', filePath);
+        expect(buffer.length).toBeGreaterThan(100);
+        expect(blockCount).toBeGreaterThan(0);
+        const parsed = (0, nbt_1.readNbt)(buffer);
+        const root = parsed.tag;
+        const blocks = root.entries.get('blocks');
+        expect(parsed.name).toBe('');
+        expect(blocks?.type).toBe(9 /* TagType.List */);
+    });
+});
+//# sourceMappingURL=nbt.test.js.map

package/dist/src/__tests__/optimizer-advanced.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer-advanced.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const structure_1 = require("../codegen/structure");
+function getFileContent(files, suffix) {
+    const file = files.find(candidate => candidate.path.endsWith(suffix));
+    if (!file) {
+        throw new Error(`Missing file: ${suffix}`);
+    }
+    return file.content;
+}
+describe('LICM', () => {
+    test('hoists loop-invariant scoreboard read out of foreach', () => {
+        const source = `
+fn turret_tick() {
+  foreach (turret in @e[tag=turret]) {
+    let range: int = scoreboard_get("config", "turret_range");
+    if (range > 0) {
+      if (range > -1) {
+        say("ready");
+      }
+    }
+  }
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const parent = getFileContent(result.files, 'data/test/function/turret_tick.mcfunction');
+        const loopBody = getFileContent(result.files, 'data/test/function/turret_tick/foreach_0.mcfunction');
+        const hoistedRead = 'execute store result score $_0 __test run scoreboard players get config test.turret_range';
+        const executeCall = 'execute as @e[tag=turret] run function test:turret_tick/foreach_0';
+        expect(parent).toContain(hoistedRead);
+        expect(parent.indexOf(hoistedRead)).toBeLessThan(parent.indexOf(executeCall));
+        expect(loopBody).not.toContain('scoreboard players get config test.turret_range');
+    });
+});
+describe('CSE', () => {
+    test('eliminates duplicate scoreboard reads', () => {
+        const source = `
+fn read_twice() {
+  let a: int = scoreboard_get(@s, "coins");
+  let b: int = scoreboard_get(@s, "coins");
+  if (a == b) {
+    say("same");
+  }
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const fn = getFileContent(result.files, 'data/test/function/read_twice.mcfunction');
+        const readMatches = fn.match(/scoreboard players get @s test\.coins/g) ?? [];
+        expect(readMatches).toHaveLength(1);
+        expect(fn).toContain('scoreboard players operation $_1 __test = $_0 __test');
+    });
+    test('reuses duplicate arithmetic sequences', () => {
+        const source = `
+fn math() {
+  let base: int = 4;
+  let a: int = base + 2;
+  let b: int = base + 2;
+  if (a == b) {
+    say("same");
+  }
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const fn = getFileContent(result.files, 'data/test/function/math.mcfunction');
+        const addMatches = fn.match(/\+= \$const_2 __test/g) ?? [];
+        expect(addMatches).toHaveLength(1);
+        expect(fn).toContain('scoreboard players operation $_1 __test = $_0 __test');
+    });
+});
+describe('setblock batching', () => {
+    test('merges 4 consecutive setblocks into fill', () => {
+        const source = `
+fn build() {
+  setblock((0, 64, 0), "minecraft:stone");
+  setblock((1, 64, 0), "minecraft:stone");
+  setblock((2, 64, 0), "minecraft:stone");
+  setblock((3, 64, 0), "minecraft:stone");
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const fn = getFileContent(result.files, 'data/test/function/build.mcfunction');
+        expect(fn).toContain('fill 0 64 0 3 64 0 minecraft:stone');
+        expect(fn).not.toContain('setblock 1 64 0 minecraft:stone');
+    });
+    test('does not merge setblocks with different blocks', () => {
+        const source = `
+fn build() {
+  setblock((0, 64, 0), "minecraft:stone");
+  setblock((1, 64, 0), "minecraft:dirt");
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const fn = getFileContent(result.files, 'data/test/function/build.mcfunction');
+        expect(fn).toContain('setblock 0 64 0 minecraft:stone');
+        expect(fn).toContain('setblock 1 64 0 minecraft:dirt');
+        expect(fn).not.toContain('fill 0 64 0 1 64 0');
+    });
+    test('does not merge non-adjacent setblocks', () => {
+        const source = `
+fn build() {
+  setblock((0, 64, 0), "minecraft:stone");
+  setblock((2, 64, 0), "minecraft:stone");
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const fn = getFileContent(result.files, 'data/test/function/build.mcfunction');
+        expect(fn).toContain('setblock 0 64 0 minecraft:stone');
+        expect(fn).toContain('setblock 2 64 0 minecraft:stone');
+        expect(fn).not.toContain('fill 0 64 0 2 64 0');
+    });
+    test('applies batching to structure target output too', () => {
+        const source = `
+fn build() {
+  setblock((0, 64, 0), "minecraft:stone");
+  setblock((1, 64, 0), "minecraft:stone");
+  setblock((2, 64, 0), "minecraft:stone");
+}
+`;
+        const result = (0, structure_1.compileToStructure)(source, 'test');
+        expect(result.blocks.some(block => block.command === 'fill 0 64 0 2 64 0 minecraft:stone')).toBe(true);
+    });
+});
+//# sourceMappingURL=optimizer-advanced.test.js.map

package/dist/src/__tests__/optimizer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer.test.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const passes_1 = require("../optimizer/passes");
+function makeFn(instrs, term = { op: 'return' }) {
+    return {
+        name: 'test',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs, term }],
+    };
+}
+describe('constantFolding', () => {
+    it('folds 2 + 3 → 5', () => {
+        const fn = makeFn([
+            { op: 'binop', dst: '$x', lhs: { kind: 'const', value: 2 }, bop: '+', rhs: { kind: 'const', value: 3 } },
+        ]);
+        const opt = (0, passes_1.constantFolding)(fn);
+        expect(opt.blocks[0].instrs[0]).toEqual({
+            op: 'assign', dst: '$x', src: { kind: 'const', value: 5 },
+        });
+    });
+    it('folds 10 / 3 → 3 (truncated int division)', () => {
+        const fn = makeFn([
+            { op: 'binop', dst: '$x', lhs: { kind: 'const', value: 10 }, bop: '/', rhs: { kind: 'const', value: 3 } },
+        ]);
+        const opt = (0, passes_1.constantFolding)(fn);
+        expect(opt.blocks[0].instrs[0].src.value).toBe(3);
+    });
+    it('folds cmp 5 == 5 → 1', () => {
+        const fn = makeFn([
+            { op: 'cmp', dst: '$r', lhs: { kind: 'const', value: 5 }, cop: '==', rhs: { kind: 'const', value: 5 } },
+        ]);
+        const opt = (0, passes_1.constantFolding)(fn);
+        expect(opt.blocks[0].instrs[0].src.value).toBe(1);
+    });
+    it('folds cmp 5 > 10 → 0', () => {
+        const fn = makeFn([
+            { op: 'cmp', dst: '$r', lhs: { kind: 'const', value: 5 }, cop: '>', rhs: { kind: 'const', value: 10 } },
+        ]);
+        const opt = (0, passes_1.constantFolding)(fn);
+        expect(opt.blocks[0].instrs[0].src.value).toBe(0);
+    });
+    it('does not fold division by zero', () => {
+        const fn = makeFn([
+            { op: 'binop', dst: '$x', lhs: { kind: 'const', value: 5 }, bop: '/', rhs: { kind: 'const', value: 0 } },
+        ]);
+        const opt = (0, passes_1.constantFolding)(fn);
+        expect(opt.blocks[0].instrs[0].op).toBe('binop');
+    });
+});
+describe('copyPropagation', () => {
+    it('propagates simple copy', () => {
+        const fn = makeFn([
+            { op: 'assign', dst: '$t0', src: { kind: 'var', name: '$x' } },
+            { op: 'binop', dst: '$y', lhs: { kind: 'var', name: '$t0' }, bop: '+', rhs: { kind: 'const', value: 1 } },
+        ]);
+        const opt = (0, passes_1.copyPropagation)(fn);
+        const binop = opt.blocks[0].instrs[1];
+        expect(binop.lhs).toEqual({ kind: 'var', name: '$x' });
+    });
+    it('propagates constant copies', () => {
+        const fn = makeFn([
+            { op: 'assign', dst: '$t0', src: { kind: 'const', value: 42 } },
+            { op: 'assign', dst: '$y', src: { kind: 'var', name: '$t0' } },
+        ]);
+        const opt = (0, passes_1.copyPropagation)(fn);
+        const second = opt.blocks[0].instrs[1];
+        expect(second.src).toEqual({ kind: 'const', value: 42 });
+    });
+});
+describe('deadCodeElimination', () => {
+    it('removes unused assignment', () => {
+        const fn = makeFn([
+            { op: 'assign', dst: '$t0', src: { kind: 'const', value: 99 } }, // unused temp
+            { op: 'assign', dst: '$t1', src: { kind: 'const', value: 1 } }, // used temp
+        ], { op: 'return', value: { kind: 'var', name: '$t1' } });
+        const opt = (0, passes_1.deadCodeElimination)(fn);
+        expect(opt.blocks[0].instrs).toHaveLength(1);
+        expect(opt.blocks[0].instrs[0].dst).toBe('$t1');
+    });
+    it('keeps call even if return value unused (side effects)', () => {
+        const fn = makeFn([
+            { op: 'call', fn: 'foo', args: [], dst: '$unused' },
+        ]);
+        const opt = (0, passes_1.deadCodeElimination)(fn);
+        expect(opt.blocks[0].instrs).toHaveLength(1);
+    });
+    it('keeps assignments referenced by raw commands', () => {
+        const fn = makeFn([
+            { op: 'assign', dst: '$used_by_raw', src: { kind: 'const', value: 7 } },
+            { op: 'raw', cmd: 'execute store result score player obj run scoreboard players get $used_by_raw rs' },
+        ]);
+        const opt = (0, passes_1.deadCodeElimination)(fn);
+        expect(opt.blocks[0].instrs).toHaveLength(2);
+        expect(opt.blocks[0].instrs[0].dst).toBe('$used_by_raw');
+    });
+});
+describe('copyPropagation – stale alias invalidation', () => {
+    it('does not propagate $tmp = $y after $y is overwritten (swap pattern)', () => {
+        // Simulates: let tmp = y; y = x % y; x = tmp
+        // The copy $tmp = $y must be invalidated when $y is reassigned.
+        // Before fix: x = tmp was propagated to x = y (new y, wrong value).
+        const fn = makeFn([
+            { op: 'assign', dst: '$tmp', src: { kind: 'var', name: '$y' } }, // tmp = y
+            { op: 'binop', dst: '$r', lhs: { kind: 'var', name: '$x' }, bop: '%', rhs: { kind: 'var', name: '$y' } }, // r = x%y
+            { op: 'assign', dst: '$y', src: { kind: 'var', name: '$r' } }, // y = r  ← stale: tmp still points to OLD y
+            { op: 'assign', dst: '$x', src: { kind: 'var', name: '$tmp' } }, // x = tmp (should NOT be x = y)
+        ]);
+        const opt = (0, passes_1.copyPropagation)(fn);
+        const instrs = opt.blocks[0].instrs;
+        const xAssign = instrs.find((i) => i.dst === '$x');
+        // x = tmp must NOT be optimised to x = $y (stale) or x = $r (new y).
+        // It should stay as x = $tmp (the original copy).
+        expect(xAssign.src).toEqual({ kind: 'var', name: '$tmp' });
+    });
+    it('still propagates simple non-conflicting copies', () => {
+        // a = 5; b = a; c = b → after propagation b and c should both be const 5
+        const fn = makeFn([
+            { op: 'assign', dst: '$a', src: { kind: 'const', value: 5 } },
+            { op: 'assign', dst: '$b', src: { kind: 'var', name: '$a' } },
+            { op: 'assign', dst: '$c', src: { kind: 'var', name: '$b' } },
+        ]);
+        const opt = (0, passes_1.copyPropagation)(fn);
+        const instrs = opt.blocks[0].instrs;
+        const cAssign = instrs.find((i) => i.dst === '$c');
+        expect(cAssign.src).toEqual({ kind: 'const', value: 5 });
+    });
+});
+describe('optimize pipeline', () => {
+    it('combines all passes', () => {
+        // t0 = 2 + 3  (→ constant fold → t0 = 5)
+        // x = t0      (→ copy prop → x = 5)
+        // unused = 0  (→ DCE → removed)
+        // return x
+        const fn = makeFn([
+            { op: 'binop', dst: '$t0', lhs: { kind: 'const', value: 2 }, bop: '+', rhs: { kind: 'const', value: 3 } },
+            { op: 'assign', dst: '$x', src: { kind: 'var', name: '$t0' } },
+            { op: 'assign', dst: '$t1', src: { kind: 'const', value: 0 } }, // unused temp, should be removed
+        ], { op: 'return', value: { kind: 'var', name: '$x' } });
+        const opt = (0, passes_1.optimize)(fn);
+        const instrs = opt.blocks[0].instrs;
+        // $t1 (unused temp) should be gone
+        expect(instrs.some((i) => i.dst === '$t1')).toBe(false);
+        // $x should be const 5 (after folding + propagation)
+        const xInstr = instrs.find((i) => i.dst === '$x');
+        expect(xInstr?.src).toEqual({ kind: 'const', value: 5 });
+    });
+});
+//# sourceMappingURL=optimizer.test.js.map