redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/e2e/basic.test.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * End-to-end tests for the v2 compiler pipeline.
+ *
+ * These tests compile RedScript source through the full pipeline
+ * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
+ * the generated .mcfunction output contains expected MC commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+describe('e2e: basic compilation', () => {
+    test('simple arithmetic function produces scoreboard commands', () => {
+        const source = `
+      fn add(a: int, b: int): int {
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        const addFn = getFile(result.files, 'add.mcfunction');
+        expect(addFn).toBeDefined();
+        expect(addFn).toContain('scoreboard players operation');
+        expect(addFn).toContain('__test');
+    });
+    test('pack.mcmeta is generated with pack_format 26', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'demo' });
+        const meta = getFile(result.files, 'pack.mcmeta');
+        expect(meta).toBeDefined();
+        const parsed = JSON.parse(meta);
+        expect(parsed.pack.pack_format).toBe(26);
+    });
+    test('load.mcfunction creates scoreboard objective', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'mypack' });
+        const load = getFile(result.files, 'load.mcfunction');
+        expect(load).toBeDefined();
+        expect(load).toContain('scoreboard objectives add __mypack dummy');
+    });
+    test('@tick function appears in tick.json', () => {
+        const source = `
+      @tick fn game_tick(): void {
+        let x: int = 1;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ticktest' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeDefined();
+        const parsed = JSON.parse(tickJson);
+        expect(parsed.values).toContain('ticktest:game_tick');
+    });
+    test('@load function appears in load.json', () => {
+        const source = `
+      @load fn setup(): void {
+        let x: int = 42;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'loadtest' });
+        const loadJson = getFile(result.files, 'load.json');
+        expect(loadJson).toBeDefined();
+        const parsed = JSON.parse(loadJson);
+        expect(parsed.values).toContain('loadtest:setup');
+        // load.json should also reference the objective-init load function
+        expect(parsed.values).toContain('loadtest:load');
+    });
+    test('if/else produces conditional call pattern', () => {
+        const source = `
+      fn check(x: int): int {
+        if (x > 0) {
+          return 1;
+        } else {
+          return 0;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'cond' });
+        // The main function should contain call_if_matches / call_unless_matches
+        const checkFn = getFile(result.files, 'check.mcfunction');
+        expect(checkFn).toBeDefined();
+        expect(checkFn).toContain('execute if score');
+        expect(checkFn).toContain('matches');
+        expect(checkFn).toContain('run function');
+    });
+    test('while loop produces loop structure with recursive call', () => {
+        const source = `
+      fn count(): void {
+        let i: int = 0;
+        while (i < 10) {
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'loop' });
+        // There should be a loop body function that calls itself (or a header)
+        const fnFiles = result.files.filter(f => f.path.endsWith('.mcfunction'));
+        expect(fnFiles.length).toBeGreaterThan(1); // main + at least one extracted block
+        // At least one file should have a conditional call pattern for the loop
+        const allContent = fnFiles.map(f => f.content).join('\n');
+        expect(allContent).toContain('execute if score');
+        expect(allContent).toContain('run function');
+    });
+    test('function names are lowercased in output paths', () => {
+        const source = `fn MyFunc(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const fn = result.files.find(f => f.path.includes('myfunc.mcfunction'));
+        expect(fn).toBeDefined();
+    });
+    test('constant assignment produces score_set', () => {
+        const source = `
+      fn init(): int {
+        let x: int = 42;
+        return x;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'cst' });
+        const fn = getFile(result.files, 'init.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players set');
+        expect(fn).toContain('42');
+    });
+    test('load.json always includes namespace:load', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'abc' });
+        const loadJson = getFile(result.files, 'load.json');
+        expect(loadJson).toBeDefined();
+        const parsed = JSON.parse(loadJson);
+        expect(parsed.values).toContain('abc:load');
+    });
+    test('no tick.json when no @tick functions', () => {
+        const source = `fn noop(): void {}`;
+        const result = (0, compile_1.compile)(source, { namespace: 'notick' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeUndefined();
+    });
+});
+//# sourceMappingURL=basic.test.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * End-to-end tests for @coroutine decorator.
+ *
+ * Compiles RedScript with @coroutine through the full pipeline and
+ * verifies generated .mcfunction output and tick.json registration.
+ */
+export {};

package/dist/src/__tests__/e2e/coroutine.test.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * End-to-end tests for @coroutine decorator.
+ *
+ * Compiles RedScript with @coroutine through the full pipeline and
+ * verifies generated .mcfunction output and tick.json registration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+function getFileNames(files) {
+    return files.map(f => f.path);
+}
+describe('e2e: @coroutine', () => {
+    test('@coroutine loop function generates dispatcher in tick.json', () => {
+        const source = `
+      @coroutine(batch=10)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeDefined();
+        const parsed = JSON.parse(tickJson);
+        // The generated tick dispatcher should be registered
+        const hasCoroTick = parsed.values.some((v) => v.includes('_coro_'));
+        expect(hasCoroTick).toBe(true);
+    });
+    test('@coroutine generates continuation mcfunction files', () => {
+        const source = `
+      @coroutine(batch=5)
+      fn heavy_loop(): void {
+        let i: int = 0;
+        while (i < 1000) {
+          let x: int = i + 1;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        const paths = getFileNames(result.files);
+        // Should have at least one continuation function file
+        const contFiles = paths.filter(p => p.includes('_coro_') && p.includes('_cont_'));
+        expect(contFiles.length).toBeGreaterThanOrEqual(1);
+        // Should have a dispatcher tick function file (may include sub-function files)
+        const tickFiles = paths.filter(p => p.includes('_coro_') && p.includes('_tick'));
+        expect(tickFiles.length).toBeGreaterThanOrEqual(1);
+    });
+    test('@coroutine with onDone generates call to callback', () => {
+        const source = `
+      fn after_done(): void {
+        let x: int = 42;
+      }
+
+      @coroutine(batch=10, onDone=after_done)
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        // The continuation files should reference after_done somewhere
+        const contFiles = result.files.filter(f => f.path.includes('_coro_') && f.path.includes('_cont_'));
+        const allContent = contFiles.map(f => f.content).join('\n');
+        expect(allContent).toContain('after_done');
+    });
+    test('@coroutine function without loops still compiles', () => {
+        const source = `
+      @coroutine(batch=10)
+      fn no_loop(): void {
+        let x: int = 1;
+        let y: int = x + 2;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        expect(result.files.length).toBeGreaterThan(0);
+        // Should still produce continuation + dispatcher
+        const paths = getFileNames(result.files);
+        const contFiles = paths.filter(p => p.includes('_coro_'));
+        expect(contFiles.length).toBeGreaterThanOrEqual(2); // at least cont + tick
+    });
+    test('@coroutine preserves non-coroutine functions', () => {
+        const source = `
+      fn helper(): int {
+        return 42;
+      }
+
+      @coroutine(batch=10)
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        const helperFn = getFile(result.files, 'helper.mcfunction');
+        expect(helperFn).toBeDefined();
+    });
+    test('default batch value is 10 when not specified', () => {
+        // @coroutine without batch should default to batch=10
+        // We test by ensuring compilation succeeds
+        const source = `
+      @coroutine
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        expect(result.files.length).toBeGreaterThan(0);
+        const paths = getFileNames(result.files);
+        const contFiles = paths.filter(p => p.includes('_coro_'));
+        expect(contFiles.length).toBeGreaterThanOrEqual(2);
+    });
+});
+//# sourceMappingURL=coroutine.test.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * End-to-end tests for MC 1.20.2+ macro function support in the v2 pipeline.
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), the compiler should
+ * automatically compile it as a macro function using $-prefixed syntax and
+ * call it via `function ns:fn with storage rs:macro_args`.
+ */
+export {};

package/dist/src/__tests__/e2e/macros.test.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * End-to-end tests for MC 1.20.2+ macro function support in the v2 pipeline.
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), the compiler should
+ * automatically compile it as a macro function using $-prefixed syntax and
+ * call it via `function ns:fn with storage rs:macro_args`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// ---------------------------------------------------------------------------
+// Macro function detection
+// ---------------------------------------------------------------------------
+describe('e2e: macro function detection', () => {
+    test('function with int params in summon coords emits $-prefixed command', () => {
+        const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'spawn_zombie.mcfunction');
+        expect(fn).toBeDefined();
+        // The function body should have a $summon macro line
+        expect(fn).toContain('$summon minecraft:zombie $(x) $(y) $(z)');
+    });
+    test('function with all constant args does NOT produce macro line', () => {
+        const source = `
+      fn spawn_fixed() {
+        summon("minecraft:zombie", 100, 64, 200);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'spawn_fixed.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('summon minecraft:zombie 100 64 200');
+        // No $ prefix
+        expect(fn).not.toMatch(/^\$summon/m);
+    });
+    test('function with int params in particle coords emits $-prefixed command', () => {
+        const source = `
+      fn show_particle(x: int, y: int, z: int) {
+        particle("minecraft:flame", x, y, z);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'show_particle.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$particle minecraft:flame $(x) $(y) $(z)');
+    });
+    test('function with int params in setblock coords emits $-prefixed command', () => {
+        const source = `
+      fn place_block(x: int, y: int, z: int) {
+        setblock(x, y, z, "minecraft:stone");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'place_block.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$setblock $(x) $(y) $(z) minecraft:stone');
+    });
+    test('mixed literal and variable args: only variable args get $()', () => {
+        const source = `
+      fn teleport_y(y: int) {
+        summon("minecraft:zombie", 100, y, 200);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'teleport_y.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$summon minecraft:zombie 100 $(y) 200');
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro call site generation
+// ---------------------------------------------------------------------------
+describe('e2e: macro call site generation', () => {
+    test('call site emits store_score_to_nbt + function with storage', () => {
+        const source = `
+      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 result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const callerFn = getFile(result.files, 'caller.mcfunction');
+        expect(callerFn).toBeDefined();
+        // Should have 'function test:spawn_zombie with storage rs:macro_args'
+        expect(callerFn).toContain('with storage rs:macro_args');
+        expect(callerFn).toContain('spawn_zombie');
+    });
+    test('call site stores args to rs:macro_args NBT', () => {
+        const source = `
+      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 result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const callerFn = getFile(result.files, 'caller.mcfunction');
+        expect(callerFn).toBeDefined();
+        // Should have NBT storage setup for macro args
+        expect(callerFn).toContain('rs:macro_args');
+        expect(callerFn).toContain('with storage');
+    });
+});
+// ---------------------------------------------------------------------------
+// Float macro params (local coords)
+// ---------------------------------------------------------------------------
+describe('e2e: float macro params with local coords', () => {
+    test('float params in ^coord positions produce macro function', () => {
+        const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'draw_pt.mcfunction');
+        expect(fn).toBeDefined();
+        // Should have $particle with ^$(px) and ^$(py)
+        expect(fn).toContain('$particle minecraft:end_rod ^$(px) ^$(py) ^5');
+    });
+    test('float macro call site uses double 0.01 scale for NBT storage', () => {
+        const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+
+      fn caller() {
+        draw_pt(100.0, 200.0);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const callerFn = getFile(result.files, 'caller.mcfunction');
+        expect(callerFn).toBeDefined();
+        // Should store to NBT with double type and 0.01 scale
+        expect(callerFn).toContain('rs:macro_args');
+        expect(callerFn).toContain('double 0.01');
+        expect(callerFn).toContain('with storage rs:macro_args');
+    });
+});
+// ---------------------------------------------------------------------------
+// Non-macro functions still work
+// ---------------------------------------------------------------------------
+describe('e2e: non-macro functions', () => {
+    test('say builtin emits normal (non-macro) command', () => {
+        const source = `
+      fn greet() {
+        say("hello world");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'greet.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('say hello world');
+        // No $ prefix
+        expect(fn).not.toMatch(/^\$/m);
+    });
+    test('kill builtin emits normal command', () => {
+        const source = `
+      fn cleanup() {
+        kill(@e[tag=temp]);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'cleanup.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('kill @e[tag=temp]');
+    });
+});
+//# sourceMappingURL=macros.test.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Migration tests — representative cases from the existing 920-test suite
+ * run through the NEW v2 compiler pipeline.
+ *
+ * Pattern:
+ *   1. Compile source with src2/emit/compile.ts
+ *   2. Load .mcfunction files into MCRuntime
+ *   3. Execute functions and assert scoreboard state
+ *
+ * NOTE: v2 uses objective `__<ns>` (not `rs`), load function is `ns:load`
+ * (not `ns:__load`), and return values go to `$ret` on the objective.
+ */
+export {};