redscript-mc 2.4.0 → 2.4.1

package/dist/runtime.map.json

@@ -0,0 +1,7 @@
+{
+  "$d": "ticks",
+  "$a": "const:0",
+  "$b": "const:1",
+  "$c": "const:100",
+  "$i": "internal:ret"
+}

package/dist/src/__tests__/array-param.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests for array reference parameter passing.
+ *
+ * When a function takes an `int[]` parameter and is called with an array
+ * variable, the compiler monomorphizes the callee per-call-site so that
+ * array index reads/writes inside the callee refer to the caller's actual
+ * NBT storage path.
+ */
+export {};

package/dist/src/__tests__/array-param.test.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Tests for array reference parameter passing.
+ *
+ * When a function takes an `int[]` parameter and is called with an array
+ * variable, the compiler monomorphizes the callee per-call-site so that
+ * array index reads/writes inside the callee refer to the caller's actual
+ * NBT storage path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+function getFile(files, pathSubstr) {
+    return files.find(f => f.path.includes(pathSubstr))?.content;
+}
+function getFunctionBody(files, fnName) {
+    const content = getFile(files, `${fnName}.mcfunction`);
+    if (!content) {
+        const paths = files.map(f => f.path).join('\n');
+        throw new Error(`Function '${fnName}' not found in output. Files:\n${paths}`);
+    }
+    return content;
+}
+describe('Array reference parameter passing', () => {
+    const src = `
+    fn swap_elems(arr: int[], i: int, j: int) {
+        let tmp: int = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+    @keep fn test() {
+        let nums: int[] = [30, 10, 20];
+        swap_elems(nums, 0, 1);
+        scoreboard_set("#out", "test", nums[0]);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('compiles without error', () => {
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('a specialized swap function is generated for nums', () => {
+        const specialized = files.filter(f => f.path.includes('swap_elems__arr_'));
+        expect(specialized.length).toBeGreaterThan(0);
+    });
+    test('specialized swap function contains "with storage" for dynamic index access', () => {
+        const specialized = files.filter(f => f.path.includes('swap_elems__arr_'));
+        expect(specialized.length).toBeGreaterThan(0);
+        const allContent = specialized.map(f => f.content).join('\n');
+        expect(allContent).toContain('with storage');
+    });
+    test('specialized swap function references the correct array path (nums)', () => {
+        const specialized = files.filter(f => f.path.includes('swap_elems__arr_'));
+        const allContent = specialized.map(f => f.content).join('\n');
+        expect(allContent).toContain('nums');
+    });
+    test('test function calls the specialized swap variant', () => {
+        const testBody = getFunctionBody(files, 'test');
+        expect(testBody).toContain('swap_elems__arr_');
+    });
+    test('original unspecialized swap is not called from test', () => {
+        const testBody = getFunctionBody(files, 'test');
+        // Should not call plain 'swap_elems' (only the specialized variant)
+        expect(testBody).not.toMatch(/function test:swap_elems\b(?!__arr_)/);
+    });
+});
+//# sourceMappingURL=array-param.test.js.map

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

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

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcfunction_1 = require("../codegen/mcfunction");
+describe('generateDatapack', () => {
+    it('generates pack.mcmeta', () => {
+        const mod = { namespace: 'test', functions: [], globals: [] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const meta = files.find(f => f.path === 'pack.mcmeta');
+        expect(meta).toBeDefined();
+        expect(JSON.parse(meta.content).pack.pack_format).toBe(26);
+    });
+    it('generates __load.mcfunction with objective setup', () => {
+        const mod = { namespace: 'mypack', functions: [], globals: [{ name: 'counter', init: 0 }] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const load = files.find(f => f.path.includes('__load.mcfunction'));
+        expect(load?.content).toContain('scoreboard objectives add rs dummy');
+        expect(load?.content).toContain('scoreboard players set $counter rs 0');
+    });
+    it('generates function file for simple add(a, b)', () => {
+        // IR now uses { kind: 'param', index: i } for param-copy instructions,
+        // matching what the lowering emits.  Pass mangle:false so we can check
+        // readable names without worrying about sequential mangled names.
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'add',
+                    params: ['$a', '$b'],
+                    locals: ['$a', '$b', '$result'],
+                    blocks: [{
+                            label: 'entry',
+                            instrs: [
+                                // param-copy instructions (what the lowering now emits)
+                                { op: 'assign', dst: '$a', src: { kind: 'param', index: 0 } },
+                                { op: 'assign', dst: '$b', src: { kind: 'param', index: 1 } },
+                                { op: 'binop', dst: '$result', lhs: { kind: 'var', name: '$a' }, bop: '+', rhs: { kind: 'var', name: '$b' } },
+                            ],
+                            term: { op: 'return', value: { kind: 'var', name: '$result' } },
+                        }],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapackWithStats)(mod, { mangle: false }).files;
+        const fn = files.find(f => f.path.includes('add.mcfunction'));
+        expect(fn).toBeDefined();
+        // param setup emitted from the IR
+        expect(fn.content).toContain('scoreboard players operation $a rs = $p0 rs');
+        expect(fn.content).toContain('scoreboard players operation $b rs = $p1 rs');
+        // Should have add operation
+        expect(fn.content).toContain('+=');
+    });
+    it('generates tick tag for tick loop function', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'game_loop',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    isTickLoop: true,
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        // tick.json should point to __tick
+        const tickTag = files.find(f => f.path.includes('tick.json'));
+        expect(tickTag).toBeDefined();
+        expect(JSON.parse(tickTag.content).values).toContain('mypack:__tick');
+        // __tick.mcfunction should call the game_loop function
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('function mypack:game_loop');
+    });
+    it('generates conditional branches with execute if/unless', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'check',
+                    params: [],
+                    locals: ['cond'],
+                    blocks: [
+                        {
+                            label: 'entry',
+                            instrs: [
+                                { op: 'assign', dst: 'cond', src: { kind: 'const', value: 1 } },
+                            ],
+                            term: { op: 'jump_if', cond: 'cond', then: 'then_block', else_: 'else_block' },
+                        },
+                        {
+                            label: 'then_block',
+                            instrs: [{ op: 'raw', cmd: 'say hello' }],
+                            term: { op: 'return' },
+                        },
+                        {
+                            label: 'else_block',
+                            instrs: [{ op: 'raw', cmd: 'say goodbye' }],
+                            term: { op: 'return' },
+                        },
+                    ],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const entry = files.find(f => f.path.endsWith('check.mcfunction'));
+        expect(entry?.content).toContain('execute if score $cond rs matches 1..');
+        expect(entry?.content).toContain('execute if score $cond rs matches ..0');
+    });
+    it('generates advancement json for event decorators', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'on_mine_diamond',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventTrigger: { kind: 'advancement', value: 'story/mine_diamond' },
+                }],
+        };
+        const result = (0, mcfunction_1.generateDatapackWithStats)(mod);
+        const advancement = result.advancements.find(f => f.path === 'data/mypack/advancements/on_advancement_on_mine_diamond.json');
+        expect(advancement).toBeDefined();
+        const json = JSON.parse(advancement.content);
+        expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond');
+        expect(json.rewards.function).toBe('mypack:on_mine_diamond');
+    });
+    it('generates static event dispatcher in __tick', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'handle_death',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+                }, {
+                    name: 'handle_death_2',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death');
+        expect(tickFn.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death_2');
+        expect(tickFn.content).toContain('tag @a[tag=rs.just_died] remove rs.just_died');
+    });
+});
+//# sourceMappingURL=codegen.test.js.map

package/dist/src/__tests__/debug-compile.test.d.ts

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

package/dist/src/__tests__/debug-compile.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../compile");
+test('debug check_score compilation', () => {
+    const source = `
+    fn check_score() {
+      let x: int = scoreboard_get("#check_x", #test_score);
+      if (x > 5) {
+        scoreboard_set("#check_x", #result, 1);
+      } else {
+        scoreboard_set("#check_x", #result, 0);
+      }
+    }
+  `;
+    const result = (0, compile_1.compile)(source, { namespace: 'inline_test' });
+    for (const file of result.files) {
+        if (!file.path.includes('pack.mcmeta')) {
+            console.log(`=== ${file.path} ===`);
+            console.log(file.content);
+        }
+    }
+    expect(true).toBe(true);
+});
+//# sourceMappingURL=debug-compile.test.js.map

package/dist/src/__tests__/debug-compile2.test.d.ts

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

package/dist/src/__tests__/debug-compile2.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../compile");
+test('debug check_score compilation full', () => {
+    const source = `
+    fn check_score() {
+      let x: int = scoreboard_get("#check_x", #test_score);
+      if (x > 5) {
+        scoreboard_set("#check_x", #result, 1);
+      } else {
+        scoreboard_set("#check_x", #result, 0);
+      }
+    }
+  `;
+    const result = (0, compile_1.compile)(source, { namespace: 'inline_test' });
+    console.log('Files:', result.files.map(f => f.path).join('\n'));
+    expect(true).toBe(true);
+});
+//# sourceMappingURL=debug-compile2.test.js.map

package/dist/src/__tests__/debug-compile3.test.d.ts

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

package/dist/src/__tests__/debug-compile3.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../compile");
+test('debug simple scoreboard', () => {
+    const source = `
+    fn check_score() {
+      let x: int = scoreboard_get("#check_x", #test_score);
+      if (x > 5) {
+        scoreboard_set("#check_x", #result, 1);
+      }
+    }
+  `;
+    const result = (0, compile_1.compile)(source, { namespace: 'inline_test' });
+    for (const file of result.files) {
+        if (file.path.includes('check_score') && !file.path.includes('mcmeta')) {
+            console.log(`=== ${file.path} ===`);
+            console.log(file.content);
+        }
+    }
+    expect(true).toBe(true);
+});
+//# sourceMappingURL=debug-compile3.test.js.map

package/dist/src/__tests__/debug-wm.test.d.ts

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

package/dist/src/__tests__/debug-wm.test.js

@@ -0,0 +1,50 @@
+"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 compile_1 = require("../compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+test('debug world_manager compilation', () => {
+    const source = fs.readFileSync(path.join(__dirname, '../examples/world_manager.mcrs'), 'utf-8');
+    const result = (0, compile_1.compile)(source, { namespace: 'world_manager' });
+    for (const file of result.files) {
+        if (!file.path.includes('pack.mcmeta') && !file.path.includes('load.json') && !file.path.includes('tick.json')) {
+            console.log(`=== ${file.path} ===`);
+            console.log(file.content);
+        }
+    }
+    expect(true).toBe(true);
+});
+//# sourceMappingURL=debug-wm.test.js.map

package/dist/src/__tests__/debug_gen.d.ts

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

package/dist/src/__tests__/debug_gen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+test('parser handles generic functions with typeParams', () => {
+    const source = `
+  fn max<T>(a: T, b: T): T {
+    if (a > b) { return a; }
+    return b;
+  }
+  fn use_max(): int {
+    return max(3, 5);
+  }
+`;
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    expect(ast.declarations).toHaveLength(2);
+    const [maxFn, useMaxFn] = ast.declarations;
+    expect(maxFn.name).toBe('max');
+    expect(maxFn.typeParams).toHaveLength(1);
+    expect(useMaxFn.name).toBe('use_max');
+    expect(useMaxFn.typeParams).toHaveLength(0);
+});
+//# sourceMappingURL=debug_gen.js.map

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../compile");
+test('tick_test compilation shows scoreboard_get/set output', () => {
+    const result = (0, compile_1.compile)(`
+    @tick
+    fn on_tick() {
+      scoreboard_set("#tick_counter", #ticks, scoreboard_get("#tick_counter", #ticks) + 1);
+    }
+  `, { namespace: 'tick_test' });
+    for (const f of result.files) {
+        if (!f.path.includes('pack.mcmeta')) {
+            console.log('=== ' + f.path + ' ===');
+            console.log(f.content);
+        }
+    }
+    expect(result.files.length).toBeGreaterThan(0);
+});
+//# sourceMappingURL=debug_scoreboard.test.js.map

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lower_1 = require("../mir/lower");
+const parser_1 = require("../parser");
+const typechecker_1 = require("../typechecker");
+test('tick_test MIR shows add operation', () => {
+    const source = `
+    @tick
+    fn on_tick() {
+      scoreboard_set("#tick_counter", #ticks, scoreboard_get("#tick_counter", #ticks) + 1);
+    }
+  `;
+    const parsed = (0, parser_1.parse)(source);
+    const hir = (0, typechecker_1.typecheck)(parsed, source, { strict: false });
+    const mir = (0, lower_1.compileToMIR)(hir);
+    for (const fn of mir.functions) {
+        console.log(`=== fn ${fn.name} ===`);
+        for (const block of fn.blocks) {
+            console.log(`Block ${block.label}:`);
+            for (const instr of block.instrs) {
+                console.log('  ', JSON.stringify(instr));
+            }
+        }
+    }
+    expect(true).toBe(true);
+});
+//# sourceMappingURL=debug_scoreboard2.test.js.map

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../compile");
+test('tick_test add operation preserved', () => {
+    // Simpler case to test: basic arithmetic with scoreboard  
+    const result = (0, compile_1.compile)(`
+    fn test() {
+      let x: int = scoreboard_get("#counter", #obj);
+      scoreboard_set("#counter", #obj, x + 1);
+    }
+  `, { namespace: 'ns' });
+    for (const f of result.files) {
+        if (!f.path.includes('pack.mcmeta')) {
+            console.log('=== ' + f.path + ' ===');
+            console.log(f.content);
+        }
+    }
+    expect(true).toBe(true);
+});
+test('tick_test inline expression', () => {
+    // This is the exact form that fails
+    const result = (0, compile_1.compile)(`
+    fn test() {
+      scoreboard_set("#counter", #obj, scoreboard_get("#counter", #obj) + 1);
+    }
+  `, { namespace: 'ns' });
+    for (const f of result.files) {
+        if (!f.path.includes('pack.mcmeta')) {
+            console.log('=== ' + f.path + ' ===');
+            console.log(f.content);
+        }
+    }
+    // Should contain: add 1
+    const fnFile = result.files.find(f => f.path.includes('/test.mcfunction'));
+    expect(fnFile?.content).toContain('add');
+});
+//# sourceMappingURL=debug_scoreboard3.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * End-to-End Tests
+ *
+ * Tests the complete pipeline: Source → Lexer → Parser → HIR → MIR → LIR → emit
+ */
+export {};