redscript-mc 1.2.30 → 2.0.0

package/dist/src/__tests__/mc-syntax.test.d.ts

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

package/dist/src/__tests__/mc-syntax.test.js

@@ -0,0 +1,124 @@
+"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 path = __importStar(require("path"));
+const compile_1 = require("../compile");
+const mc_validator_1 = require("../mc-validator");
+const FIXTURE_PATH = path.join(__dirname, 'fixtures', 'mc-commands-1.21.4.json');
+const EXAMPLES = ['counter', 'arena', 'shop', 'quiz', 'turret'];
+function getCommands(source, namespace = 'test') {
+    const result = (0, compile_1.compile)(source, { namespace });
+    expect(result.success).toBe(true);
+    expect(result.files).toBeDefined();
+    return (result.files ?? [])
+        .filter(file => file.path.endsWith('.mcfunction'))
+        .flatMap(file => file.content.split('\n'))
+        .filter(line => line.trim().length > 0);
+}
+function validateSource(validator, source, namespace) {
+    return getCommands(source, namespace)
+        .map(cmd => ({ cmd, result: validator.validate(cmd) }))
+        .filter(entry => !entry.result.valid)
+        .map(entry => ({ cmd: entry.cmd, error: entry.result.error }));
+}
+describe('MC Command Syntax Validation', () => {
+    const validator = new mc_validator_1.MCCommandValidator(FIXTURE_PATH);
+    test('counter example generates valid MC commands', () => {
+        const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.mcrs'), 'utf-8');
+        const errors = validateSource(validator, src, 'counter');
+        expect(errors).toHaveLength(0);
+    });
+    EXAMPLES.forEach(name => {
+        test(`${name}.mcrs generates valid MC commands`, () => {
+            const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.mcrs`), 'utf-8');
+            const errors = validateSource(validator, src, name);
+            if (errors.length > 0) {
+                console.log('Invalid commands:', errors);
+            }
+            expect(errors).toHaveLength(0);
+        });
+    });
+    test('string interpolation generates valid tellraw', () => {
+        const errors = validateSource(validator, `
+fn chat() {
+    let score: int = 7;
+    say("You have \${score} points");
+}
+`, 'interpolation');
+        expect(errors).toHaveLength(0);
+    });
+    test('f-strings generate valid tellraw/title commands', () => {
+        const errors = validateSource(validator, `
+fn chat() {
+    let score: int = 7;
+    say(f"You have {score} points");
+    tellraw(@a, f"Score: {score}");
+    actionbar(@s, f"Score: {score}");
+    title(@s, f"Score: {score}");
+}
+`, 'f-string');
+        expect(errors).toHaveLength(0);
+    });
+    test('array operations generate valid data commands', () => {
+        const errors = validateSource(validator, `
+fn arrays() {
+    let arr: int[] = [];
+    arr.push(4);
+    arr.push(9);
+    let popped: int = arr.pop();
+    let len: int = arr.len;
+
+    scoreboard_set("arrays", "len", len);
+    scoreboard_set("arrays", "last", popped);
+}
+`, 'arrays');
+        expect(errors).toHaveLength(0);
+    });
+    test('match generates valid execute commands', () => {
+        const errors = validateSource(validator, `
+fn choose() {
+    let choice: int = 2;
+    match (choice) {
+        1 => { say("one"); }
+        2 => { say("two"); }
+        _ => { say("other"); }
+    }
+}
+`, 'matching');
+        expect(errors).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=mc-syntax.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

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

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