redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/emit/modules-rewrite.test.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Coverage for src/emit/modules.ts — rewriteCallsInProgram and rewriteStmt/rewriteExpr
+ *
+ * Targets the rewriting of various AST node types when module imports are resolved:
+ * - while stmt with imported call
+ * - for_range stmt with imported call
+ * - match stmt with imported call in arm
+ * - execute stmt with imported call in body
+ * - let_destruct with imported call
+ * - member/member_assign/index/index_assign expressions using imported fn
+ * - array_lit, struct_lit, tuple_lit with imported fn
+ * - invoke, assign, binary, unary expressions
+ * - implBlock methods are rewritten
+ * - return stmt with value using imported fn
+ * - if stmt with else using imported fn
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../../emit/modules");
+function modules(main, libBody, namespace = 'rw') {
+    return (0, modules_1.compileModules)([
+        {
+            name: 'lib',
+            source: `
+        module lib;
+        export fn helper(): int { return 42; }
+        ${libBody}
+      `,
+        },
+        {
+            name: 'main',
+            source: `
+        import lib::helper;
+        ${main}
+      `,
+        },
+    ], { namespace });
+}
+// ── while stmt ─────────────────────────────────────────────────────────────
+test('rewrite: while stmt with imported call in cond', () => {
+    const result = modules(`
+    fn entry(): int {
+      while (helper() > 0) {
+        return 1;
+      }
+      return 0;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── return stmt ─────────────────────────────────────────────────────────────
+test('rewrite: return stmt with imported call', () => {
+    const result = modules(`
+    fn entry(): int { return helper(); }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── if with else ────────────────────────────────────────────────────────────
+test('rewrite: if stmt with else using imported call', () => {
+    const result = modules(`
+    fn entry(): int {
+      if (helper() > 0) {
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── binary / unary / assign ─────────────────────────────────────────────────
+test('rewrite: binary expr with imported call', () => {
+    const result = modules(`
+    fn entry(): int {
+      let x = helper() + helper();
+      return x;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+test('rewrite: assign expr with imported call', () => {
+    const result = modules(`
+    fn entry(): int {
+      let x = 0;
+      x = helper();
+      return x;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── member / member_assign ──────────────────────────────────────────────────
+test('rewrite: member access with imported call', () => {
+    const result = modules(`
+    struct Wrapper { val: int }
+    fn make(): Wrapper { return Wrapper { val: helper() }; }
+    fn entry(): int {
+      let w = make();
+      return w.val;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── array_lit ─────────────────────────────────────────────────────────────
+test('rewrite: array_lit with imported call', () => {
+    const result = modules(`
+    fn entry(): int {
+      let arr: int[] = [helper(), helper()];
+      return 0;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── for_range stmt ─────────────────────────────────────────────────────────
+test('rewrite: for_range with imported call in bounds', () => {
+    const result = modules(`
+    fn entry(): int {
+      let sum = 0;
+      for i in 0..helper() {
+        sum = sum + i;
+      }
+      return sum;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── struct_lit ─────────────────────────────────────────────────────────────
+test('rewrite: struct_lit with imported call in field', () => {
+    const result = modules(`
+    struct Pair { a: int, b: int }
+    fn entry(): int {
+      let p = Pair { a: helper(), b: 0 };
+      return p.a;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── impl block methods rewriting ───────────────────────────────────────────
+test('rewrite: impl block method uses imported symbol', () => {
+    const result = modules(`
+    struct Calculator { offset: int }
+    impl Calculator {
+      fn compute(self): int {
+        return self.offset + helper();
+      }
+    }
+    fn entry(): int {
+      let c = Calculator { offset: 10 };
+      return c.compute();
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry') || f.path.includes('compute'))).toBe(true);
+});
+// ── match stmt ────────────────────────────────────────────────────────────
+test('rewrite: match stmt with imported call in arm body', () => {
+    const result = modules(`
+    enum Status { Active, Inactive }
+    fn entry(): int {
+      let s: Status = Status::Active;
+      match s {
+        Status::Active => { return helper(); }
+        Status::Inactive => { return 0; }
+      }
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── execute stmt ─────────────────────────────────────────────────────────
+test('rewrite: execute block with imported call', () => {
+    const result = modules(`
+    fn entry(): int {
+      execute as @a run {
+        let x = helper();
+      }
+      return 0;
+    }
+  `, '');
+    expect(result.files.some(f => f.path.includes('entry'))).toBe(true);
+});
+// ── 3 modules — pack.mcmeta only emitted once ─────────────────────────────
+test('pack.mcmeta emitted only once in multi-module output', () => {
+    const result = (0, modules_1.compileModules)([
+        { name: 'a', source: 'module a;\nexport fn fa(): int { return 1; }' },
+        { name: 'b', source: 'module b;\nexport fn fb(): int { return 2; }' },
+        { name: 'main', source: 'import a::fa;\nimport b::fb;\nfn entry(): int { return fa() + fb(); }' },
+    ], { namespace: 'multi' });
+    const packMeta = result.files.filter(f => f.path === 'pack.mcmeta');
+    expect(packMeta).toHaveLength(1);
+});
+// ── @tick and @load functions in modules ──────────────────────────────────
+test('modules with @tick and @load functions emit tick/load tags', () => {
+    const result = (0, modules_1.compileModules)([
+        {
+            name: 'game',
+            source: `
+        module game;
+        @tick
+        fn on_tick(): void { raw("say tick"); }
+      `,
+        },
+    ], { namespace: 'ticked' });
+    const tickTag = result.files.find(f => f.path.includes('tick.json'));
+    expect(tickTag).toBeDefined();
+});
+//# sourceMappingURL=modules-rewrite.test.js.map

package/dist/src/__tests__/emit/source-map.test.d.ts

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

package/dist/src/__tests__/emit/source-map.test.js

@@ -0,0 +1,167 @@
+"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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const index_1 = require("../../index");
+function getFile(files, filePath) {
+    const file = files.find(entry => entry.path === filePath);
+    if (!file) {
+        throw new Error(`Missing file: ${filePath}\nAvailable:\n${files.map(entry => entry.path).join('\n')}`);
+    }
+    return file.content;
+}
+function compileWithSource(source, filePath = 'src/main.mcrs') {
+    return (0, index_1.compile)(source, {
+        namespace: 'trace',
+        filePath,
+        generateSourceMap: true,
+    });
+}
+describe('emit source map output', () => {
+    test('generates namespace sourcemap.json', () => {
+        const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`);
+        const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json'));
+        expect(map.version).toBe(1);
+        expect(map.sources).toEqual(['src/main.mcrs']);
+    });
+    test('mcfunction files include generated-from and source headers', () => {
+        const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`);
+        const fn = getFile(result.files, 'data/trace/function/attack.mcfunction');
+        expect(fn).toContain('# Generated from: src/main.mcrs:2 (fn attack)');
+        expect(fn).toContain('# Source: fn attack(target: string) -> void');
+    });
+    test('mcfunction files include src comments before semantic blocks', () => {
+        const result = compileWithSource(`
+fn attack(target: string): void {
+  say("one");
+  say(target);
+}
+`);
+        const fn = getFile(result.files, 'data/trace/function/attack.mcfunction');
+        expect(fn).toContain('# src: src/main.mcrs:3');
+        expect(fn).toContain('# src: src/main.mcrs:4');
+    });
+    test('namespace sourcemap maps function names back to source names', () => {
+        const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`);
+        const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json'));
+        expect(map.mappings['trace:attack']).toMatchObject({
+            source: 0,
+            line: 2,
+            name: 'attack',
+        });
+    });
+    test('supports multi-file namespace sourcemaps', () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-sm-'));
+        const srcDir = path.join(tempDir, 'src');
+        fs.mkdirSync(srcDir, { recursive: true });
+        const helperPath = path.join(srcDir, 'helper.mcrs');
+        const mainPath = path.join(srcDir, 'main.mcrs');
+        fs.writeFileSync(helperPath, `
+fn support(): void {
+  say("helper");
+}
+`);
+        fs.writeFileSync(mainPath, `
+import helper;
+
+fn attack(): void {
+  support();
+}
+`);
+        const result = (0, index_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'trace',
+            filePath: mainPath,
+            generateSourceMap: true,
+        });
+        const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json'));
+        expect(map.sources).toEqual([mainPath, helperPath]);
+        expect(map.mappings['trace:attack']).toMatchObject({ source: 0, line: 4, name: 'attack' });
+        expect(map.mappings['trace:support']).toMatchObject({ source: 1, line: 2, name: 'support' });
+    });
+    test('keeps per-file sourcemap sidecars', () => {
+        const result = compileWithSource(`
+fn attack(target: string): void {
+  say(target);
+}
+`);
+        const map = JSON.parse(getFile(result.files, 'data/trace/function/attack.sourcemap.json'));
+        expect(map.generatedFile).toBe('data/trace/function/attack.mcfunction');
+        expect(map.mappings.length).toBeGreaterThan(0);
+    });
+    test('execute-run helper call sites keep source comments for runtime tracebacks', () => {
+        const result = compileWithSource(`
+fn attack(): void {
+  execute as @a run {
+    say("hit");
+  }
+}
+`);
+        const main = getFile(result.files, 'data/trace/function/attack.mcfunction');
+        const helperPath = result.files.find(file => file.path.includes('__exec_') && file.path.endsWith('.mcfunction'))?.path;
+        expect(main).toContain('# src: src/main.mcrs:3');
+        expect(main).toContain('run function trace:');
+        expect(helperPath).toBeDefined();
+        const helper = getFile(result.files, helperPath);
+        expect(helper).toContain('# Generated from: src/main.mcrs:3');
+    });
+    test('namespace sourcemap records nested helper functions', () => {
+        const result = compileWithSource(`
+fn attack(flag: bool): void {
+  if (flag) {
+    say("hit");
+  }
+}
+`);
+        const map = JSON.parse(getFile(result.files, 'trace.sourcemap.json'));
+        const helperKey = Object.keys(map.mappings).find(key => key.includes('__then_'));
+        expect(helperKey).toBeDefined();
+        expect(map.mappings[helperKey]).toMatchObject({ source: 0, line: 2, name: expect.any(String) });
+    });
+});
+//# sourceMappingURL=source-map.test.js.map

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

@@ -113,13 +113,18 @@ describe('enum: parser', () => {
         expect(matchStmt.kind).toBe('match');
         if (matchStmt.kind === 'match') {
             expect(matchStmt.arms).toHaveLength(2);
+            // Enum variant patterns now parse as PatEnum (previously PatExpr wrapping path_expr)
             expect(matchStmt.arms[0].pattern).toMatchObject({
-                kind: 'PatExpr',
-                expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Idle' },
+                kind: 'PatEnum',
+                enumName: 'Phase',
+                variant: 'Idle',
+                bindings: [],
             });
             expect(matchStmt.arms[1].pattern).toMatchObject({
-                kind: 'PatExpr',
-                expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Moving' },
+                kind: 'PatEnum',
+                enumName: 'Phase',
+                variant: 'Moving',
+                bindings: [],
             });
         }
     });

package/dist/src/__tests__/error-recovery.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Error Recovery Tests
+ *
+ * Verifies that the parser continues after encountering syntax errors,
+ * collecting all diagnostics rather than stopping at the first one.
+ */
+export {};

package/dist/src/__tests__/error-recovery.test.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * Error Recovery Tests
+ *
+ * Verifies that the parser continues after encountering syntax errors,
+ * collecting all diagnostics rather than stopping at the first one.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const diagnostics_1 = require("../diagnostics");
+function parseWithErrors(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const parser = new parser_1.Parser(tokens, source);
+    let parsedFns = [];
+    try {
+        const ast = parser.parse(namespace);
+        parsedFns = ast.declarations.map(fn => fn.name);
+    }
+    catch (_) {
+        // Partial AST not returned on throw, but we can inspect parseErrors below
+    }
+    return {
+        errors: parser.parseErrors,
+        parsedFns,
+    };
+}
+describe('Parser Error Recovery', () => {
+    describe('top-level declaration recovery', () => {
+        it('reports all errors from multiple broken functions', () => {
+            const source = `
+fn good1() {
+  let x: int = 42;
+}
+
+fn bad1( {
+  let y: int = 1;
+}
+
+fn good2() {
+  let z: int = 99;
+}
+
+fn bad2() {
+  let w: int = ;
+}
+
+fn good3() {}
+`;
+            const { errors } = parseWithErrors(source);
+            // Should have collected at least 2 errors (bad1 and bad2)
+            expect(errors.length).toBeGreaterThanOrEqual(2);
+        });
+        it('collects errors with correct line numbers', () => {
+            const source = `fn a() {}
+fn b( {
+  let x = 1;
+}
+fn c() {
+  let y = ;
+}
+fn d() {}`;
+            const { errors } = parseWithErrors(source);
+            expect(errors.length).toBeGreaterThanOrEqual(2);
+            // Each error should have a valid location
+            for (const err of errors) {
+                expect(err.location.line).toBeGreaterThan(0);
+                expect(err.location.col).toBeGreaterThan(0);
+            }
+        });
+        it('errors are DiagnosticError instances with ParseError kind', () => {
+            const source = `
+fn broken( {
+  return 1;
+}
+fn also_broken() {
+  let x = ;
+}
+`;
+            const { errors } = parseWithErrors(source);
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+            for (const err of errors) {
+                expect(err).toBeInstanceOf(diagnostics_1.DiagnosticError);
+                expect(err.kind).toBe('ParseError');
+            }
+        });
+        it('recovers and continues parsing after struct error', () => {
+            const source = `
+struct Bad {
+  name
+}
+
+struct Good {
+  x: int
+  y: int
+}
+`;
+            const { errors } = parseWithErrors(source);
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+        });
+        it('recovers from a broken top-level const and still parses later functions', () => {
+            const source = `
+const BAD: = 1;
+
+fn good_after_error() {
+  return;
+}
+`;
+            const { errors, parsedFns } = parseWithErrors(source);
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+            expect(parsedFns).toContain('good_after_error');
+        });
+    });
+    describe('block-level (statement) recovery', () => {
+        it('collects multiple errors within a single function body', () => {
+            const source = `
+fn multi_error_fn() {
+  let x: int = ;
+  let y: int = 42;
+  let z: int = ;
+  let w: int = 100;
+}
+`;
+            const { errors } = parseWithErrors(source);
+            // Should have at least 2 statement-level errors
+            expect(errors.length).toBeGreaterThanOrEqual(2);
+        });
+        it('continues parsing after a bad statement', () => {
+            // The second let statement should be parseable even after the first is broken
+            const source = `
+fn test_fn() {
+  let x: int = ;
+  let y: int = 42;
+}
+`;
+            const { errors } = parseWithErrors(source);
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+        });
+        it('recovers after consuming a bad statement semicolon and keeps later statements', () => {
+            const source = `
+fn test_fn() {
+  let x: int = ;
+  let y: int = 42;
+  return;
+}
+`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const parser = new parser_1.Parser(tokens, source);
+            const ast = parser.parse('test');
+            expect(parser.parseErrors.length).toBeGreaterThanOrEqual(1);
+            expect(ast.declarations[0].body.some(stmt => stmt.kind === 'return')).toBe(true);
+        });
+        it('recovers at block end without consuming the closing brace', () => {
+            const source = `
+fn broken() {
+  let x: int = }
+
+fn after_broken() {
+  return;
+}
+`;
+            const { errors, parsedFns } = parseWithErrors(source);
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+            expect(parsedFns).toContain('broken');
+            expect(parsedFns).toContain('after_broken');
+        });
+    });
+    describe('error message quality', () => {
+        it('formats errors with source pointer', () => {
+            const source = `fn foo( {\n  return 1;\n}`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const parser = new parser_1.Parser(tokens, source);
+            try {
+                parser.parse('test');
+            }
+            catch (_) { }
+            expect(parser.parseErrors.length).toBeGreaterThanOrEqual(1);
+            const formatted = parser.parseErrors[0].format();
+            expect(formatted).toContain('[ParseError]');
+            expect(formatted).toContain('^');
+            expect(formatted).toContain('line');
+        });
+        it('error location points to the problematic token', () => {
+            const source = 'fn f() {\n  let x = ;\n}';
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const parser = new parser_1.Parser(tokens, source);
+            try {
+                parser.parse('test');
+            }
+            catch (_) { }
+            expect(parser.parseErrors.length).toBeGreaterThanOrEqual(1);
+            const err = parser.parseErrors[0];
+            // The error should be on line 2 (the `let x = ;` line)
+            expect(err.location.line).toBe(2);
+        });
+    });
+    describe('parseErrors array is populated', () => {
+        it('is empty for valid programs', () => {
+            const source = 'fn foo() { let x: int = 42; }';
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const parser = new parser_1.Parser(tokens, source);
+            parser.parse('test');
+            expect(parser.parseErrors).toHaveLength(0);
+        });
+        it('is populated when errors occur', () => {
+            const source = 'fn foo( {';
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const parser = new parser_1.Parser(tokens, source);
+            try {
+                parser.parse('test');
+            }
+            catch (_) { }
+            expect(parser.parseErrors.length).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=error-recovery.test.js.map

package/dist/src/__tests__/events-types-extra.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extra coverage for src/events/types.ts
+ * Targets the uncovered branches in toTypeNode (named types, struct fallback)
+ * and parseEventParam error path.
+ *
+ * Since toTypeNode is private, we access it indirectly by monkey-patching
+ * the EVENT_TYPES constant via compile-level tests and by testing the exported
+ * functions more thoroughly.
+ */
+export {};