redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/compiler/module-import.test.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Module import system tests
+ *
+ * Tests for `import <name>` whole-module file imports, where:
+ * - player_utils.mcrs declares `module player_utils`
+ * - main.mcrs uses `import player_utils` (no `::` — imports the whole module by file)
+ *
+ * Unlike the Phase 5b `compileModules` API which handles multi-module datapack
+ * compilation, these tests verify that the `compile()` function can resolve
+ * and merge whole-module imports at the file level.
+ */
+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 os = __importStar(require("os"));
+const compile_1 = require("../../emit/compile");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse();
+}
+/** Create a temporary directory with given files, return its path. */
+function makeTmpDir(files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-module-'));
+    for (const [name, content] of Object.entries(files)) {
+        fs.writeFileSync(path.join(dir, name), content, 'utf-8');
+    }
+    return dir;
+}
+function cleanupDir(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+// ---------------------------------------------------------------------------
+// Parser: `import <name>` (whole-module) is parsed correctly
+// ---------------------------------------------------------------------------
+describe('parser: import <name> (whole-module)', () => {
+    test('parses `import player_utils;` as whole-module import (no symbol)', () => {
+        const ast = parse(`
+      import player_utils;
+      fn main() { }
+    `);
+        expect(ast.imports).toHaveLength(1);
+        const imp = ast.imports[0];
+        expect(imp.moduleName).toBe('player_utils');
+        expect(imp.symbol).toBeUndefined();
+    });
+    test('parses `import player_utils` without semicolon', () => {
+        const ast = parse(`
+      import player_utils
+      fn main() { }
+    `);
+        expect(ast.imports).toHaveLength(1);
+        expect(ast.imports[0].symbol).toBeUndefined();
+    });
+    test('parses `import math::sin;` as symbol import (existing behaviour preserved)', () => {
+        const ast = parse(`
+      module main;
+      import math::sin;
+    `);
+        const imp = ast.imports[0];
+        expect(imp.moduleName).toBe('math');
+        expect(imp.symbol).toBe('sin');
+    });
+    test('parses `import math::*;` as wildcard symbol import (existing behaviour preserved)', () => {
+        const ast = parse(`
+      import math::*;
+    `);
+        const imp = ast.imports[0];
+        expect(imp.symbol).toBe('*');
+    });
+    test('multiple whole-module imports', () => {
+        const ast = parse(`
+      import player_utils;
+      import math_utils;
+      fn main() { }
+    `);
+        expect(ast.imports).toHaveLength(2);
+        expect(ast.imports[0].moduleName).toBe('player_utils');
+        expect(ast.imports[1].moduleName).toBe('math_utils');
+        for (const imp of ast.imports) {
+            expect(imp.symbol).toBeUndefined();
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Compiler: whole-module import resolution (file-based)
+// ---------------------------------------------------------------------------
+describe('compiler: whole-module import resolution', () => {
+    test('resolves and merges a whole-module import from a relative file', () => {
+        const dir = makeTmpDir({
+            'player_utils.mcrs': `
+module player_utils;
+fn get_health_pct(name: string): int {
+  return 75;
+}
+`,
+            'main.mcrs': `
+import player_utils;
+fn on_tick() {
+  let pct: int = get_health_pct("Steve");
+}
+`,
+        });
+        try {
+            const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8');
+            const result = (0, compile_1.compile)(source, {
+                namespace: 'test',
+                filePath: path.join(dir, 'main.mcrs'),
+            });
+            expect(result.success).toBe(true);
+            const files = result.files.filter(f => f.path.endsWith('.mcfunction'));
+            // get_health_pct should be emitted (reachable from on_tick)
+            const allContent = files.map(f => f.content).join('\n');
+            expect(allContent.length).toBeGreaterThan(0);
+        }
+        finally {
+            cleanupDir(dir);
+        }
+    });
+    test('throws a diagnostic error when module file is not found', () => {
+        expect(() => {
+            (0, compile_1.compile)(`
+        import nonexistent_module;
+        fn main() { }
+      `, { namespace: 'test', filePath: '/tmp/fake/main.mcrs' });
+        }).toThrow(/Module 'nonexistent_module' not found/);
+    });
+    test('whole-module import allows calling imported functions', () => {
+        const dir = makeTmpDir({
+            'utils.mcrs': `
+module utils;
+fn add(a: int, b: int): int {
+  return a + b;
+}
+`,
+            'main.mcrs': `
+import utils;
+fn compute(): int {
+  return add(10, 20);
+}
+`,
+        });
+        try {
+            const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8');
+            const result = (0, compile_1.compile)(source, {
+                namespace: 'ns',
+                filePath: path.join(dir, 'main.mcrs'),
+            });
+            expect(result.success).toBe(true);
+        }
+        finally {
+            cleanupDir(dir);
+        }
+    });
+    test('imported module functions are DCE-eligible (not exported as entry points)', () => {
+        const dir = makeTmpDir({
+            'helper.mcrs': `
+module helper;
+fn internal_fn(): int {
+  return 42;
+}
+`,
+            'main.mcrs': `
+import helper;
+fn main_run() {
+  let x: int = internal_fn();
+}
+`,
+        });
+        try {
+            const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8');
+            const result = (0, compile_1.compile)(source, {
+                namespace: 'test',
+                filePath: path.join(dir, 'main.mcrs'),
+            });
+            expect(result.success).toBe(true);
+            // internal_fn should NOT appear in tick.json or load.json as an entry point
+            const tickTag = result.files.find(f => f.path.includes('tick.json'));
+            const loadTag = result.files.find(f => f.path.includes('load.json'));
+            if (tickTag)
+                expect(tickTag.content).not.toContain('internal_fn');
+            if (loadTag)
+                expect(loadTag.content).not.toContain('internal_fn');
+        }
+        finally {
+            cleanupDir(dir);
+        }
+    });
+    test('does not import the same module twice (deduplication)', () => {
+        const dir = makeTmpDir({
+            'shared.mcrs': `
+module shared;
+fn shared_fn(): int { return 1; }
+`,
+            'a.mcrs': `
+module a;
+import shared;
+fn use_shared(): int { return shared_fn(); }
+`,
+            'main.mcrs': `
+import a;
+import shared;
+fn main() {
+  let x: int = use_shared();
+  let y: int = shared_fn();
+}
+`,
+        });
+        try {
+            const source = fs.readFileSync(path.join(dir, 'main.mcrs'), 'utf-8');
+            // Should not throw a duplicate function error
+            const result = (0, compile_1.compile)(source, {
+                namespace: 'test',
+                filePath: path.join(dir, 'main.mcrs'),
+            });
+            expect(result.success).toBe(true);
+        }
+        finally {
+            cleanupDir(dir);
+        }
+    });
+});
+//# sourceMappingURL=module-import.test.js.map

package/dist/src/__tests__/compiler/option-extensions.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for Option extensions:
+ * - while let Some(x) = opt { ... }
+ * - opt.unwrap_or(default)
+ */
+export {};

package/dist/src/__tests__/compiler/option-extensions.test.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Tests for Option extensions:
+ * - while let Some(x) = opt { ... }
+ * - opt.unwrap_or(default)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const compile_1 = require("../../emit/compile");
+function parse(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens).parse(namespace);
+}
+function getFile(files, pathSubstr) {
+    const exact = files.find(f => f.path.endsWith(`function/${pathSubstr}.mcfunction`));
+    if (exact)
+        return exact.content;
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// ---------------------------------------------------------------------------
+// Parser: while let
+// ---------------------------------------------------------------------------
+describe('while let: Parser', () => {
+    it('parses while let Some(x) = opt { ... }', () => {
+        const prog = parse(`
+      fn f(p: Option<int>): void {
+        while let Some(x) = p {
+          let y: int = x;
+        }
+      }
+    `);
+        const stmt = prog.declarations[0].body[0];
+        expect(stmt.kind).toBe('while_let_some');
+        if (stmt.kind === 'while_let_some') {
+            expect(stmt.binding).toBe('x');
+            expect(stmt.init).toEqual({ kind: 'ident', name: 'p' });
+            expect(stmt.body.length).toBe(1);
+        }
+    });
+    it('parses while let Some(val) = expr { body }', () => {
+        const prog = parse(`
+      fn f(): void {
+        let opt: Option<int> = Some(5);
+        while let Some(n) = opt {
+          let z: int = n;
+        }
+      }
+    `);
+        const whileStmt = prog.declarations[0].body[1];
+        expect(whileStmt.kind).toBe('while_let_some');
+        if (whileStmt.kind === 'while_let_some') {
+            expect(whileStmt.binding).toBe('n');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Parser: unwrap_or
+// ---------------------------------------------------------------------------
+describe('unwrap_or: Parser', () => {
+    it('parses opt.unwrap_or(0)', () => {
+        const prog = parse(`
+      fn f(p: Option<int>): void {
+        let x: int = p.unwrap_or(0);
+      }
+    `);
+        const letStmt = prog.declarations[0].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('unwrap_or');
+            if (letStmt.init.kind === 'unwrap_or') {
+                expect(letStmt.init.opt).toEqual({ kind: 'ident', name: 'p' });
+                expect(letStmt.init.default_).toEqual({ kind: 'int_lit', value: 0 });
+            }
+        }
+    });
+    it('parses chained: fn_call().unwrap_or(42)', () => {
+        const prog = parse(`
+      fn make(): Option<int> { return None; }
+      fn f(): void {
+        let val: int = make().unwrap_or(42);
+      }
+    `);
+        const letStmt = prog.declarations[1].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('unwrap_or');
+            if (letStmt.init.kind === 'unwrap_or') {
+                expect(letStmt.init.default_).toEqual({ kind: 'int_lit', value: 42 });
+            }
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// E2E: unwrap_or compilation
+// ---------------------------------------------------------------------------
+describe('unwrap_or: E2E', () => {
+    it('compiles Some(5).unwrap_or(0) — result should be 5', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = Some(5);
+        let val: int = p.unwrap_or(0);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+        // Should contain scoreboard operations
+        expect(fn).toContain('scoreboard');
+    });
+    it('compiles None.unwrap_or(99) — compiles without error', () => {
+        // When opt is None, unwrap_or branches to the merge block with the default value
+        // The default 99 may be DCE'd if val is unused; we just verify compilation succeeds
+        const source = `
+      fn test(): void {
+        let p: Option<int> = None;
+        let val: int = p.unwrap_or(99);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+        // has=0 should appear for None
+        expect(fn).toContain('0');
+    });
+    it('compiles function-returning Option with unwrap_or', () => {
+        const source = `
+      fn maybe(): Option<int> {
+        return Some(7);
+      }
+      fn test(): void {
+        let val: int = maybe().unwrap_or(0);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// E2E: while let compilation
+// ---------------------------------------------------------------------------
+describe('while let: E2E', () => {
+    it('compiles while let Some(x) = opt with known-Some value', () => {
+        const source = `
+      fn test(): void {
+        let opt: Option<int> = Some(1);
+        while let Some(x) = opt {
+          let y: int = x;
+          opt = None;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        // Should generate a conditional/branch structure
+        const hasConditional = result.files.some(f => f.content.includes('execute if score') || f.content.includes('scoreboard'));
+        expect(hasConditional).toBe(true);
+    });
+    it('compiles while let Some(x) = opt with None — loop body never runs', () => {
+        const source = `
+      fn test(): void {
+        let opt: Option<int> = None;
+        while let Some(x) = opt {
+          let y: int = x;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('compiles while let with function-returning Option', () => {
+        const source = `
+      fn next(): Option<int> {
+        return None;
+      }
+      fn test(): void {
+        let opt: Option<int> = next();
+        while let Some(x) = opt {
+          let y: int = x;
+          opt = next();
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=option-extensions.test.js.map

package/dist/src/__tests__/compiler/profile-decorator.test.d.ts

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

package/dist/src/__tests__/compiler/profile-decorator.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const typechecker_1 = require("../../typechecker");
+function getFile(files, path) {
+    const file = files.find(entry => entry.path === path);
+    if (!file) {
+        throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`);
+    }
+    return file.content;
+}
+function parseDecorators(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return ast.declarations[0]?.decorators.map(decorator => decorator.name) ?? [];
+}
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return new typechecker_1.TypeChecker(source).check(ast);
+}
+describe('@profile decorator', () => {
+    test('parser records @profile on the function', () => {
+        expect(parseDecorators(`
+      @profile
+      fn expensive_calculation() {}
+    `)).toContain('profile');
+    });
+    test('typechecker rejects duplicate @profile decorators', () => {
+        const errors = typeCheck(`
+      @profile
+      @profile
+      fn expensive_calculation() {}
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('multiple @profile decorators');
+    });
+    test('emits profiler instrumentation and helper functions only in debug mode', () => {
+        const source = `
+      @profile
+      fn expensive_calculation() {
+        let value: int = 42;
+        say("done");
+      }
+    `;
+        const debugResult = (0, compile_1.compile)(source, { namespace: 'profile_test', debug: true });
+        const regularResult = (0, compile_1.compile)(source, { namespace: 'profile_test' });
+        const main = getFile(debugResult.files, 'data/profile_test/function/expensive_calculation.mcfunction');
+        const load = getFile(debugResult.files, 'data/profile_test/function/load.mcfunction');
+        const reset = getFile(debugResult.files, 'data/profile_test/function/__profiler_reset.mcfunction');
+        const report = getFile(debugResult.files, 'data/profile_test/function/__profiler_report.mcfunction');
+        expect(main).toContain('# __profiler_start_expensive_calculation');
+        expect(main).toContain('execute store result score #prof_start_expensive_calculation __time run time query gametime');
+        expect(main).toContain('# __profiler_end_expensive_calculation');
+        expect(main).toContain('scoreboard players operation #prof_total_expensive_calculation __profile += #prof_delta_expensive_calculation __time');
+        expect(main).toContain('scoreboard players add #prof_count_expensive_calculation __profile 1');
+        expect(load).toContain('scoreboard objectives add __time dummy');
+        expect(load).toContain('scoreboard objectives add __profile dummy');
+        expect(reset).toContain('scoreboard players set #prof_total_expensive_calculation __profile 0');
+        expect(reset).toContain('scoreboard players set #prof_count_expensive_calculation __profile 0');
+        expect(report).toContain('"text":"[profile] expensive_calculation: total="');
+        expect(report).toContain('"name":"#prof_total_expensive_calculation"');
+        expect(regularResult.files.find(file => file.path === 'data/profile_test/function/__profiler_reset.mcfunction')).toBeUndefined();
+        expect(getFile(regularResult.files, 'data/profile_test/function/expensive_calculation.mcfunction')).not.toContain('__profiler_start_expensive_calculation');
+    });
+});
+//# sourceMappingURL=profile-decorator.test.js.map

package/dist/src/__tests__/compiler/string-advanced.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for enhanced string features:
+ * - Enhanced f-string interpolation (expressions, function calls, array indexing)
+ * - Multi-line triple-quoted strings
+ * - int_to_str / bool_to_str builtin functions
+ */
+export {};