redscript-mc 1.2.30 → 2.1.0

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

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Tests for Phase 6a: Option<T> — null safety
+ *
+ * Covers:
+ * - Parsing Option<T> type annotation
+ * - Parsing Some(expr) and None expressions
+ * - Parsing if let Some(x) = opt { ... }
+ * - HIR lowering of Option nodes
+ * - MIR lowering: Option compiles to two slots (has + val)
+ * - if let Some(x) = opt → checks has slot, binds val slot
+ * - Function returning Option<int>
+ * - Correct scoreboard commands generated
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const compile_1 = require("../emit/compile");
+const lower_1 = require("../hir/lower");
+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) {
+    // Prefer exact function file match: look for function/<name>.mcfunction
+    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 tests
+// ---------------------------------------------------------------------------
+describe('Option: Parser', () => {
+    it('parses Option<int> type annotation', () => {
+        const prog = parse('fn f(): Option<int> {}');
+        expect(prog.declarations[0].returnType).toEqual({ kind: 'option', inner: { kind: 'named', name: 'int' } });
+    });
+    it('parses Option<bool> parameter type', () => {
+        const prog = parse('fn f(x: Option<bool>): void {}');
+        expect(prog.declarations[0].params[0].type).toEqual({ kind: 'option', inner: { kind: 'named', name: 'bool' } });
+    });
+    it('parses Some(42) expression', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = Some(42); }');
+        const letStmt = prog.declarations[0].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('some_lit');
+            if (letStmt.init.kind === 'some_lit') {
+                expect(letStmt.init.value).toEqual({ kind: 'int_lit', value: 42 });
+            }
+        }
+    });
+    it('parses None expression', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = None; }');
+        const letStmt = prog.declarations[0].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('none_lit');
+        }
+    });
+    it('parses if let Some(x) = opt { ... }', () => {
+        const prog = parse('fn f(p: Option<int>): void { if let Some(x) = p { let y: int = x; } }');
+        const stmt = prog.declarations[0].body[0];
+        expect(stmt.kind).toBe('if_let_some');
+        if (stmt.kind === 'if_let_some') {
+            expect(stmt.binding).toBe('x');
+            expect(stmt.init).toEqual({ kind: 'ident', name: 'p' });
+            expect(stmt.then.length).toBe(1);
+        }
+    });
+    it('parses if let Some(x) = opt { } else { }', () => {
+        const prog = parse(`
+      fn f(p: Option<int>): void {
+        if let Some(x) = p {
+          let a: int = x;
+        } else {
+          let b: int = 0;
+        }
+      }
+    `);
+        const stmt = prog.declarations[0].body[0];
+        expect(stmt.kind).toBe('if_let_some');
+        if (stmt.kind === 'if_let_some') {
+            expect(stmt.else_).toBeDefined();
+            expect(stmt.else_.length).toBe(1);
+        }
+    });
+    it('does not treat Some as identifier', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = Some(1); }');
+        if (prog.declarations[0].body[0].kind === 'let') {
+            const init = prog.declarations[0].body[0].init;
+            expect(init.kind).toBe('some_lit');
+        }
+    });
+    it('does not treat None as identifier', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = None; }');
+        if (prog.declarations[0].body[0].kind === 'let') {
+            const init = prog.declarations[0].body[0].init;
+            expect(init.kind).toBe('none_lit');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// HIR lowering tests
+// ---------------------------------------------------------------------------
+describe('Option: HIR lowering', () => {
+    function hirOf(source) {
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        const ast = new parser_1.Parser(tokens).parse('test');
+        return (0, lower_1.lowerToHIR)(ast);
+    }
+    it('lowers some_lit through HIR unchanged', () => {
+        const hir = hirOf('fn f(): void { let x: Option<int> = Some(42); }');
+        const fn0 = hir.functions[0];
+        const letStmt = fn0.body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('some_lit');
+        }
+    });
+    it('lowers none_lit through HIR unchanged', () => {
+        const hir = hirOf('fn f(): void { let x: Option<int> = None; }');
+        const fn0 = hir.functions[0];
+        const letStmt = fn0.body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('none_lit');
+        }
+    });
+    it('lowers if_let_some through HIR unchanged', () => {
+        const hir = hirOf('fn f(p: Option<int>): void { if let Some(x) = p {} }');
+        const fn0 = hir.functions[0];
+        const stmt = fn0.body[0];
+        expect(stmt.kind).toBe('if_let_some');
+        if (stmt.kind === 'if_let_some') {
+            expect(stmt.binding).toBe('x');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Compilation (E2E) tests
+// ---------------------------------------------------------------------------
+describe('Option: E2E compilation', () => {
+    it('compiles Some(42) assignment — sets has=1, val=42', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = Some(42);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players set');
+        // has slot should be set to 1, val slot should be set to 42
+        expect(fn).toContain('1');
+        expect(fn).toContain('42');
+    });
+    it('compiles None assignment — sets has=0', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = None;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players set');
+        expect(fn).toContain('0');
+    });
+    it('compiles if let Some(x) = p — conditional on has slot', () => {
+        const source = `
+      fn test(p: Option<int>): void {
+        if let Some(x) = p {
+          let y: int = x;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        // Should generate a conditional call checking has slot
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('compiles function returning Option<int> Some value', () => {
+        const source = `
+      fn make_some(): Option<int> {
+        return Some(99);
+      }
+      fn test(): void {
+        let p: Option<int> = make_some();
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'make_some');
+        expect(fn).toBeDefined();
+        // Should set ret_has=1 and ret_val=99
+        expect(fn).toContain('$ret_has');
+        expect(fn).toContain('99');
+    });
+    it('compiles function returning Option<int> None value', () => {
+        const source = `
+      fn make_none(): Option<int> {
+        return None;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'make_none');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$ret_has');
+        // has=0
+        expect(fn).toContain('0');
+    });
+    it('compiles full if-let Some pattern with body using bound variable', () => {
+        // Use a function that returns Option<int> so the condition is not constant-folded
+        const source = `
+      fn maybe_val(): Option<int> {
+        return Some(10);
+      }
+      @tick
+      fn tick(): void {
+        let p: Option<int> = maybe_val();
+        if let Some(n) = p {
+          let doubled: int = n + n;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        // Verify a conditional function split was created
+        const hasConditional = result.files.some(f => f.content.includes('execute if score'));
+        expect(hasConditional).toBe(true);
+    });
+    it('compiles if-let with else branch', () => {
+        const source = `
+      @tick
+      fn tick(): void {
+        let q: Option<int> = None;
+        if let Some(v) = q {
+          let a: int = v;
+        } else {
+          let b: int = 0;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('compiles nested if-let inside if-let', () => {
+        const source = `
+      fn test(): void {
+        let a: Option<int> = Some(1);
+        let b: Option<int> = Some(2);
+        if let Some(x) = a {
+          if let Some(y) = b {
+            let sum: int = x + y;
+          }
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('generated scoreboard slots are unique per function and variable', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = Some(5);
+        let q: Option<int> = None;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+    });
+});
+//# sourceMappingURL=option.test.js.map

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

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

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Tests for @schedule decorator (Phase 5c)
+ *
+ * @schedule(ticks=N) generates a _schedule_xxx.mcfunction wrapper that
+ * emits `schedule function ns:xxx Nt`.
+ */
+export {};

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

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Tests for @schedule decorator (Phase 5c)
+ *
+ * @schedule(ticks=N) generates a _schedule_xxx.mcfunction wrapper that
+ * emits `schedule function ns:xxx Nt`.
+ */
+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('@schedule decorator', () => {
+    test('@schedule(ticks=20) generates _schedule wrapper with 20t', () => {
+        const source = `
+      @schedule(ticks=20)
+      fn after_one_second(): void {
+        say("One second passed!");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const wrapper = getFile(result.files, '_schedule_after_one_second.mcfunction');
+        expect(wrapper).toBeDefined();
+        expect(wrapper).toBe('schedule function test:after_one_second 20t\n');
+    });
+    test('@schedule(ticks=1) generates _schedule wrapper with 1t', () => {
+        const source = `
+      @schedule(ticks=1)
+      fn next_tick(): void {
+        say("next tick!");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const wrapper = getFile(result.files, '_schedule_next_tick.mcfunction');
+        expect(wrapper).toBeDefined();
+        expect(wrapper).toBe('schedule function ns:next_tick 1t\n');
+    });
+    test('@schedule does not affect tick.json', () => {
+        const source = `
+      @schedule(ticks=20)
+      fn deferred(): void {
+        say("deferred");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeUndefined();
+    });
+    test('@schedule coexists with @tick and @load', () => {
+        const source = `
+      @tick
+      fn game_tick(): void {
+        let x: int = 1;
+      }
+
+      @load
+      fn init(): void {
+        let y: int = 0;
+      }
+
+      @schedule(ticks=40)
+      fn two_seconds(): void {
+        say("two seconds!");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'combo' });
+        // @tick still works
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeDefined();
+        expect(JSON.parse(tickJson).values).toContain('combo:game_tick');
+        // @load still works
+        const loadJson = getFile(result.files, 'load.json');
+        expect(loadJson).toBeDefined();
+        expect(JSON.parse(loadJson).values).toContain('combo:init');
+        // @schedule generates wrapper
+        const wrapper = getFile(result.files, '_schedule_two_seconds.mcfunction');
+        expect(wrapper).toBeDefined();
+        expect(wrapper).toBe('schedule function combo:two_seconds 40t\n');
+    });
+    test('calling _schedule_xxx() invokes the schedule wrapper', () => {
+        const source = `
+      @schedule(ticks=20)
+      fn after_one_second(): void {
+        say("delayed");
+      }
+
+      fn start(): void {
+        _schedule_after_one_second();
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const startFn = getFile(result.files, 'start.mcfunction');
+        expect(startFn).toBeDefined();
+        expect(startFn).toContain('function test:_schedule_after_one_second');
+    });
+});
+//# sourceMappingURL=schedule.test.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Source Map Tests — Phase 4a
+ *
+ * Verifies that generated .sourcemap.json files correctly map output lines
+ * back to source .mcrs locations.
+ */
+export {};

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

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Source Map Tests — Phase 4a
+ *
+ * Verifies that generated .sourcemap.json files correctly map output lines
+ * back to source .mcrs locations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+function getSourceMap(files, fnSuffix) {
+    const smPath = `data/test/function/${fnSuffix}.sourcemap.json`;
+    const file = files.find(f => f.path === smPath);
+    if (!file) {
+        const paths = files.map(f => f.path).join(', ');
+        throw new Error(`Missing sourcemap: ${smPath}\nAvailable: ${paths}`);
+    }
+    return JSON.parse(file.content);
+}
+function getMcFunction(files, fnSuffix) {
+    const mcPath = `data/test/function/${fnSuffix}.mcfunction`;
+    const file = files.find(f => f.path === mcPath);
+    if (!file)
+        throw new Error(`Missing mcfunction: ${mcPath}`);
+    return file.content;
+}
+// ---------------------------------------------------------------------------
+// Basic structure
+// ---------------------------------------------------------------------------
+describe('source map — basic structure', () => {
+    it('generates sourcemap.json only when generateSourceMap=true', () => {
+        const source = `fn add(a: int, b: int): int { return a + b; }`;
+        const without = (0, index_1.compile)(source, { namespace: 'test', filePath: 'src/add.mcrs' });
+        expect(without.files.some(f => f.path.endsWith('.sourcemap.json'))).toBe(false);
+        const with_ = (0, index_1.compile)(source, { namespace: 'test', generateSourceMap: true, filePath: 'src/add.mcrs' });
+        expect(with_.files.some(f => f.path.endsWith('.sourcemap.json'))).toBe(true);
+    });
+    it('sourcemap has version=1', () => {
+        const source = `fn greet() { say("hello"); }`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/greet.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'greet');
+        expect(sm.version).toBe(1);
+    });
+    it('sourcemap generatedFile matches the mcfunction path', () => {
+        const source = `fn foo() { say("x"); }`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/foo.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'foo');
+        expect(sm.generatedFile).toBe('data/test/function/foo.mcfunction');
+    });
+    it('sources array contains the source file path', () => {
+        const source = `fn bar() { say("y"); }`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/bar.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'bar');
+        expect(sm.sources).toContain('src/bar.mcrs');
+    });
+});
+// ---------------------------------------------------------------------------
+// Mapping correctness
+// ---------------------------------------------------------------------------
+describe('source map — mapping correctness', () => {
+    it('each mapping line references a valid output line', () => {
+        const source = `
+fn simple(x: int): int {
+  let y = x + 1;
+  return y;
+}
+`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/simple.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'simple');
+        const mcfn = getMcFunction(result.files, 'simple');
+        const outputLines = mcfn.split('\n').filter(l => l.length > 0);
+        for (const mapping of sm.mappings) {
+            expect(mapping.line).toBeGreaterThanOrEqual(1);
+            expect(mapping.line).toBeLessThanOrEqual(outputLines.length);
+            expect(mapping.sourceLine).toBeGreaterThanOrEqual(1);
+            expect(mapping.sourceCol).toBeGreaterThanOrEqual(1);
+        }
+    });
+    it('source index in mappings refers to valid sources entry', () => {
+        const source = `fn calc(a: int, b: int): int { return a * b; }`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/calc.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'calc');
+        for (const m of sm.mappings) {
+            expect(m.source).toBeGreaterThanOrEqual(0);
+            expect(m.source).toBeLessThan(sm.sources.length);
+        }
+    });
+    it('mappings cover the output lines from a simple function body', () => {
+        const source = `
+fn add(a: int, b: int): int {
+  return a + b;
+}
+`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/add.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'add');
+        // There should be at least one mapping
+        expect(sm.mappings.length).toBeGreaterThan(0);
+        // All mappings should point at non-zero source lines
+        for (const m of sm.mappings) {
+            expect(m.sourceLine).toBeGreaterThan(0);
+        }
+    });
+    it('sourceLine values are ordered and correspond to source line numbers', () => {
+        const source = `
+fn multi() {
+  let a = 1;
+  let b = 2;
+  let c = a + b;
+  say("hello");
+}
+`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/multi.mcrs',
+        });
+        const sm = getSourceMap(result.files, 'multi');
+        // All mapped source lines should be in the range of the function body
+        for (const m of sm.mappings) {
+            expect(m.sourceLine).toBeGreaterThanOrEqual(2); // fn starts at line 2
+            expect(m.sourceLine).toBeLessThanOrEqual(8); // fn ends at line 8
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// No sourcemap when no filePath
+// ---------------------------------------------------------------------------
+describe('source map — no filePath', () => {
+    it('generates sourcemap with empty sources when no filePath is provided', () => {
+        const source = `fn noloc() { say("no file"); }`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            // no filePath
+        });
+        // Source map should not be generated (no sourceLoc info to record)
+        const hasSm = result.files.some(f => f.path.endsWith('.sourcemap.json'));
+        // Either no sourcemap generated, or it has empty mappings
+        if (hasSm) {
+            const sm = getSourceMap(result.files, 'noloc');
+            expect(sm.mappings.length).toBe(0);
+        }
+        // This is acceptable either way — just verify it doesn't crash
+    });
+});
+// ---------------------------------------------------------------------------
+// Nested function calls
+// ---------------------------------------------------------------------------
+describe('source map — nested function calls', () => {
+    it('each function gets its own sourcemap', () => {
+        const source = `
+fn helper(x: int): int {
+  return x * 2;
+}
+
+fn caller() {
+  let r = helper(5);
+  say("done");
+}
+`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/nested.mcrs',
+        });
+        // Both functions should have sourcemaps
+        const helperSm = getSourceMap(result.files, 'helper');
+        const callerSm = getSourceMap(result.files, 'caller');
+        expect(helperSm.mappings.length).toBeGreaterThan(0);
+        expect(callerSm.mappings.length).toBeGreaterThan(0);
+        // helper's mappings should reference lines 2-4
+        for (const m of helperSm.mappings) {
+            expect(m.sourceLine).toBeGreaterThanOrEqual(2);
+            expect(m.sourceLine).toBeLessThanOrEqual(4);
+        }
+        // caller's mappings should reference lines 7-9
+        for (const m of callerSm.mappings) {
+            expect(m.sourceLine).toBeGreaterThanOrEqual(7);
+            expect(m.sourceLine).toBeLessThanOrEqual(9);
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// sourcemap.json sidecar path
+// ---------------------------------------------------------------------------
+describe('source map — file path convention', () => {
+    it('sourcemap path replaces .mcfunction with .sourcemap.json', () => {
+        const source = `fn test_fn() { say("test"); }`;
+        const result = (0, index_1.compile)(source, {
+            namespace: 'test',
+            generateSourceMap: true,
+            filePath: 'src/test.mcrs',
+        });
+        const smFiles = result.files.filter(f => f.path.endsWith('.sourcemap.json'));
+        expect(smFiles.length).toBeGreaterThan(0);
+        for (const sf of smFiles) {
+            expect(sf.path).toMatch(/\.sourcemap\.json$/);
+            // Corresponding .mcfunction should also exist
+            const mcPath = sf.path.replace('.sourcemap.json', '.mcfunction');
+            expect(result.files.some(f => f.path === mcPath)).toBe(true);
+        }
+    });
+});
+//# sourceMappingURL=sourcemap.test.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Tests for Phase 2b: Multi-return values / Tuple types
+ *
+ * Covers:
+ * - Tuple type parsing: (int, int)
+ * - Tuple literal parsing: (a, b)
+ * - Destructuring let: let (q, r) = ...
+ * - Function return type: fn f(): (int, int)
+ * - Full compilation to scoreboard commands
+ */
+export {};