redscript-mc 1.2.30 → 2.1.0

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

@@ -1,8 +0,0 @@
-/**
- * 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/__tests__/macro.test.js

@@ -1,305 +0,0 @@
-"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')
-        .map(i => i.cmd);
-}
-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/__tests__/nbt.test.js

@@ -1,82 +0,0 @@
-"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/__tests__/optimizer-advanced.test.js

@@ -1,124 +0,0 @@
-"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/__tests__/optimizer.test.js

@@ -1,149 +0,0 @@
-"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