redscript-mc 1.2.30 → 2.1.0

package/dist/__tests__/cli.test.js

@@ -1,278 +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 index_1 = require("../index");
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
-// Note: watch command is tested manually as it's an interactive long-running process
-describe('CLI API', () => {
-    describe('imports', () => {
-        it('compiles a file with imported helpers', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'));
-            const libPath = path.join(tempDir, 'lib.mcrs');
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n');
-            fs.writeFileSync(mainPath, 'import "./lib.mcrs"\n\nfn main() { let value: int = double(2); }\n');
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'imports', filePath: mainPath });
-            expect(result.files.length).toBeGreaterThan(0);
-            expect(result.ir.functions.some(fn => fn.name === 'double')).toBe(true);
-            expect(result.ir.functions.some(fn => fn.name === 'main')).toBe(true);
-        });
-        it('deduplicates circular imports', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'));
-            const aPath = path.join(tempDir, 'a.mcrs');
-            const bPath = path.join(tempDir, 'b.mcrs');
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            fs.writeFileSync(aPath, 'import "./b.mcrs"\n\nfn from_a() -> int { return 1; }\n');
-            fs.writeFileSync(bPath, 'import "./a.mcrs"\n\nfn from_b() -> int { return from_a(); }\n');
-            fs.writeFileSync(mainPath, 'import "./a.mcrs"\n\nfn main() { let value: int = from_b(); }\n');
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'circular', filePath: mainPath });
-            expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1);
-            expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1);
-        });
-        it('uses rs-prefixed scoreboard objectives for imported stdlib files', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-'));
-            const stdlibDir = path.join(tempDir, 'src', 'stdlib');
-            const stdlibPath = path.join(stdlibDir, 'timer.mcrs');
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            fs.mkdirSync(stdlibDir, { recursive: true });
-            fs.writeFileSync(stdlibPath, 'fn tick_timer() { scoreboard_set("#rs", "timer_ticks", 1); }\n');
-            fs.writeFileSync(mainPath, 'import "./src/stdlib/timer.mcrs"\n\nfn main() { tick_timer(); }\n');
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'mygame', filePath: mainPath });
-            const tickTimer = result.files.find(file => file.path.endsWith('/tick_timer.mcfunction'));
-            expect(tickTimer?.content).toContain('scoreboard players set #rs __mygame.timer_ticks 1');
-        });
-        it('adds a call-site hash for stdlib internal scoreboard objectives', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-hash-'));
-            const stdlibDir = path.join(tempDir, 'src', 'stdlib');
-            const stdlibPath = path.join(stdlibDir, 'timer.mcrs');
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            fs.mkdirSync(stdlibDir, { recursive: true });
-            fs.writeFileSync(stdlibPath, [
-                'fn timer_start(name: string, duration: int) {',
-                '  scoreboard_set("timer_ticks", #rs, duration);',
-                '  scoreboard_set("timer_active", #rs, 1);',
-                '}',
-                '',
-            ].join('\n'));
-            fs.writeFileSync(mainPath, [
-                'import "./src/stdlib/timer.mcrs"',
-                '',
-                'fn main() {',
-                '  timer_start("x", 100);',
-                '  timer_start("x", 100);',
-                '}',
-                '',
-            ].join('\n'));
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'mygame', filePath: mainPath });
-            const timerFns = result.files.filter(file => /timer_start__callsite_[0-9a-f]{4}\.mcfunction$/.test(file.path));
-            expect(timerFns).toHaveLength(2);
-            const objectives = timerFns
-                .flatMap(file => [...file.content.matchAll(/mygame\._timer_([0-9a-f]{4})/g)].map(match => match[0]));
-            expect(new Set(objectives).size).toBe(2);
-        });
-        it('Timer::new creates timer', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-new-'));
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
-            fs.writeFileSync(mainPath, [
-                `import "${timerPath}"`,
-                '',
-                'fn main() {',
-                '  let timer: Timer = Timer::new(20);',
-                '}',
-                '',
-            ].join('\n'));
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'timernew', filePath: mainPath });
-            expect(result.typeErrors).toEqual([]);
-            const newFn = result.files.find(file => file.path.endsWith('/Timer_new.mcfunction'));
-            expect(newFn?.content).toContain('scoreboard players set timer_ticks __timernew 0');
-            expect(newFn?.content).toContain('scoreboard players set timer_active __timernew 0');
-        });
-        it('Timer.start/pause/reset', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-state-'));
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
-            fs.writeFileSync(mainPath, [
-                `import "${timerPath}"`,
-                '',
-                'fn main() {',
-                '  let timer: Timer = Timer::new(20);',
-                '  timer.start();',
-                '  timer.pause();',
-                '  timer.reset();',
-                '}',
-                '',
-            ].join('\n'));
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'timerstate', filePath: mainPath });
-            expect(result.typeErrors).toEqual([]);
-            const startFn = result.files.find(file => file.path.endsWith('/Timer_start.mcfunction'));
-            const pauseFn = result.files.find(file => file.path.endsWith('/Timer_pause.mcfunction'));
-            const resetFn = result.files.find(file => file.path.endsWith('/Timer_reset.mcfunction'));
-            expect(startFn?.content).toContain('scoreboard players set timer_active __timerstate 1');
-            expect(pauseFn?.content).toContain('scoreboard players set timer_active __timerstate 0');
-            expect(resetFn?.content).toContain('scoreboard players set timer_ticks __timerstate 0');
-        });
-        it('Timer.done returns bool', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-done-'));
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
-            fs.writeFileSync(mainPath, [
-                `import "${timerPath}"`,
-                '',
-                'fn main() {',
-                '  let timer: Timer = Timer::new(20);',
-                '  let finished: bool = timer.done();',
-                '  if (finished) {',
-                '    say("done");',
-                '  }',
-                '}',
-                '',
-            ].join('\n'));
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'timerdone', filePath: mainPath });
-            expect(result.typeErrors).toEqual([]);
-            const doneFn = result.files.find(file => file.path.endsWith('/Timer_done.mcfunction'));
-            const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'));
-            expect(doneFn?.content).toContain('scoreboard players get timer_ticks __timerdone');
-            expect(doneFn?.content).toContain('return run scoreboard players get');
-            expect(mainFn?.content).toContain('execute if score $main_finished __timerdone matches 1..');
-        });
-        it('Timer.tick increments', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-tick-'));
-            const mainPath = path.join(tempDir, 'main.mcrs');
-            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
-            fs.writeFileSync(mainPath, [
-                `import "${timerPath}"`,
-                '',
-                'fn main() {',
-                '  let timer: Timer = Timer::new(20);',
-                '  timer.start();',
-                '  timer.tick();',
-                '}',
-                '',
-            ].join('\n'));
-            const source = fs.readFileSync(mainPath, 'utf-8');
-            const result = (0, index_1.compile)(source, { namespace: 'timertick', filePath: mainPath });
-            expect(result.typeErrors).toEqual([]);
-            const tickOutput = result.files
-                .filter(file => file.path.includes('/Timer_tick'))
-                .map(file => file.content)
-                .join('\n');
-            expect(tickOutput).toContain('scoreboard players get timer_active __timertick');
-            expect(tickOutput).toContain('scoreboard players get timer_ticks __timertick');
-            expect(tickOutput).toContain(' += $const_1 __timertick');
-            expect(tickOutput).toContain('execute store result score timer_ticks __timertick run scoreboard players get $_');
-        });
-    });
-    describe('compile()', () => {
-        it('compiles simple source', () => {
-            const source = 'fn test() { say("hello"); }';
-            const result = (0, index_1.compile)(source, { namespace: 'mypack' });
-            expect(result.files.length).toBeGreaterThan(0);
-            expect(result.ast.namespace).toBe('mypack');
-            expect(result.ir.functions.length).toBe(1);
-        });
-        it('uses default namespace', () => {
-            const source = 'fn test() {}';
-            const result = (0, index_1.compile)(source);
-            expect(result.ast.namespace).toBe('redscript');
-        });
-        it('generates correct file structure', () => {
-            const source = 'fn test() { say("hello"); }';
-            const result = (0, index_1.compile)(source, { namespace: 'game' });
-            const paths = result.files.map(f => f.path);
-            expect(paths).toContain('pack.mcmeta');
-            expect(paths).toContain('data/game/function/__load.mcfunction');
-            expect(paths.some(p => p.includes('test.mcfunction'))).toBe(true);
-        });
-        it('collects optimizer stats', () => {
-            const source = `
-fn build() {
-  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: 'stats' });
-            expect(result.stats?.licmHoists).toBeGreaterThan(0);
-            expect(result.stats?.totalCommandsBefore).toBeGreaterThan(result.stats?.totalCommandsAfter ?? 0);
-            expect(result.stats?.deadCodeRemoved).toBeGreaterThanOrEqual(0);
-        });
-    });
-    describe('--stats flag', () => {
-        it('prints optimizer statistics', () => {
-            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'));
-            const inputPath = path.join(tempDir, 'input.mcrs');
-            const outputDir = path.join(tempDir, 'out');
-            fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }');
-            const stdout = (0, child_process_1.execFileSync)(process.execPath, ['-r', 'ts-node/register', path.join(process.cwd(), 'src/cli.ts'), 'compile', inputPath, '-o', outputDir, '--stats'], { cwd: process.cwd(), encoding: 'utf-8' });
-            expect(stdout).toContain('Optimizations applied:');
-            expect(stdout).toContain('setblock batching:');
-            expect(stdout).toContain('Total mcfunction commands:');
-        });
-    });
-    describe('check()', () => {
-        it('returns null for valid source', () => {
-            const source = 'fn test() { say("hello"); }';
-            const error = (0, index_1.check)(source);
-            expect(error).toBeNull();
-        });
-        it('returns error for invalid source', () => {
-            const source = 'fn test( { say("hello"); }'; // Missing )
-            const error = (0, index_1.check)(source);
-            expect(error).toBeInstanceOf(Error);
-        });
-        it('returns error for syntax errors', () => {
-            const source = 'fn test() { let x = ; }'; // Missing value
-            const error = (0, index_1.check)(source);
-            expect(error).toBeInstanceOf(Error);
-        });
-    });
-});
-//# sourceMappingURL=cli.test.js.map

package/dist/__tests__/codegen.test.js

@@ -1,152 +0,0 @@
-"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/__tests__/e2e.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * End-to-End Tests
- *
- * Tests the complete pipeline: Source → Lexer → Parser → Lowering → Optimizer → CodeGen
- */
-export {};