redscript-mc 2.0.0 → 2.1.0

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 {};

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

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * 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
+ */
+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 parseStmt(source) {
+    const program = parse(`fn _test() { ${source} }`);
+    return program.declarations[0].body[0];
+}
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// ---------------------------------------------------------------------------
+// Parser tests
+// ---------------------------------------------------------------------------
+describe('Tuple: Parser', () => {
+    it('parses tuple type (int, int) as return type', () => {
+        const program = parse('fn f(a: int, b: int): (int, int) {}');
+        const fn = program.declarations[0];
+        expect(fn.returnType).toEqual({ kind: 'tuple', elements: [
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+            ] });
+    });
+    it('parses tuple type with 3 elements', () => {
+        const program = parse('fn f(): (int, bool, int) {}');
+        expect(program.declarations[0].returnType).toEqual({ kind: 'tuple', elements: [
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'bool' },
+                { kind: 'named', name: 'int' },
+            ] });
+    });
+    it('parses tuple literal expression (a, b)', () => {
+        const program = parse(`fn _test(a: int, b: int): (int, int) { return (a, b); }`);
+        const ret = program.declarations[0].body[0];
+        expect(ret.kind).toBe('return');
+        if (ret.kind === 'return' && ret.value) {
+            expect(ret.value.kind).toBe('tuple_lit');
+            if (ret.value.kind === 'tuple_lit') {
+                expect(ret.value.elements).toHaveLength(2);
+                expect(ret.value.elements[0]).toMatchObject({ kind: 'ident', name: 'a' });
+                expect(ret.value.elements[1]).toMatchObject({ kind: 'ident', name: 'b' });
+            }
+        }
+    });
+    it('parses destructuring let statement', () => {
+        const stmt = parseStmt('let (q, r) = divmod(10, 3);');
+        expect(stmt.kind).toBe('let_destruct');
+        if (stmt.kind === 'let_destruct') {
+            expect(stmt.names).toEqual(['q', 'r']);
+            expect(stmt.init).toMatchObject({ kind: 'call', fn: 'divmod' });
+        }
+    });
+    it('parses destructuring with 3 bindings', () => {
+        const stmt = parseStmt('let (a, b, c) = get_triple(1);');
+        expect(stmt.kind).toBe('let_destruct');
+        if (stmt.kind === 'let_destruct') {
+            expect(stmt.names).toEqual(['a', 'b', 'c']);
+        }
+    });
+    it('does not confuse (expr) grouped expression with tuple literal', () => {
+        const program = parse(`fn _test(): int { return (1 + 2); }`);
+        const ret = program.declarations[0].body[0];
+        expect(ret.kind).toBe('return');
+        if (ret.kind === 'return' && ret.value) {
+            expect(ret.value.kind).toBe('binary');
+        }
+    });
+    it('still parses function type (int) -> int correctly', () => {
+        const program = parse('fn apply(f: (int) -> int, x: int): int {}');
+        const param = program.declarations[0].params[0];
+        expect(param.type).toEqual({ kind: 'function_type', params: [{ kind: 'named', name: 'int' }], return: { kind: 'named', name: 'int' } });
+    });
+});
+// ---------------------------------------------------------------------------
+// E2E compilation tests
+// ---------------------------------------------------------------------------
+describe('Tuple: E2E compilation', () => {
+    test('basic divmod function compiles and writes $ret_0 and $ret_1', () => {
+        const source = `
+      fn divmod(a: int, b: int): (int, int) {
+        return (a / b, a % b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'divmod.mcfunction');
+        expect(fn).toBeDefined();
+        // MIR __rf_0 → LIR $ret_0 (see lir/lower.ts slot() method)
+        expect(fn).toContain('$ret_0');
+        expect(fn).toContain('$ret_1');
+    });
+    test('destructuring let reads from $ret_ slots after call', () => {
+        const source = `
+      fn divmod(a: int, b: int): (int, int) {
+        return (a / b, a % b);
+      }
+      fn use_divmod(): int {
+        let (q, r) = divmod(10, 3);
+        return q + r;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'use_divmod.mcfunction');
+        expect(fn).toBeDefined();
+        // Should call divmod and then read from $ret_ slots
+        expect(fn).toContain('divmod');
+        expect(fn).toContain('$ret_0');
+        expect(fn).toContain('$ret_1');
+    });
+    test('tuple literal assigned directly via destructuring', () => {
+        const source = `
+      fn make_sum(a: int, b: int): int {
+        let (x, y) = (a + 1, b + 2);
+        return x + y;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'make_sum.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players operation');
+    });
+    test('tuple values used in subsequent computation', () => {
+        const source = `
+      fn divmod(a: int, b: int): (int, int) {
+        return (a / b, a % b);
+      }
+      fn compute(): int {
+        let (q, r) = divmod(10, 3);
+        return q + r;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'compute.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players operation');
+    });
+    test('3-tuple return and destructuring', () => {
+        const source = `
+      fn triple(a: int): (int, int, int) {
+        return (a, a + 1, a + 2);
+      }
+      fn use_triple(): int {
+        let (x, y, z) = triple(5);
+        return x + y + z;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const tripleFn = getFile(result.files, 'triple.mcfunction');
+        expect(tripleFn).toBeDefined();
+        expect(tripleFn).toContain('$ret_0');
+        expect(tripleFn).toContain('$ret_1');
+        expect(tripleFn).toContain('$ret_2');
+    });
+    test('enum and tuple combined: return (int, Phase)', () => {
+        const source = `
+      enum Phase { Idle, Running, Done }
+      fn get_state(): (int, int) {
+        return (42, Phase::Running);
+      }
+      fn use_state(): int {
+        let (count, phase) = get_state();
+        return count + phase;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'get_state.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$ret_0');
+        expect(fn).toContain('$ret_1');
+        // Phase::Running = 1
+        expect(fn).toContain('1');
+    });
+    test('tuple return type appears in generated mcfunction with correct objective', () => {
+        const source = `
+      fn minmax(a: int, b: int): (int, int) {
+        return (a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const fn = getFile(result.files, 'minmax.mcfunction');
+        expect(fn).toBeDefined();
+        // MIR __rf_0 → LIR $ret_0
+        expect(fn).toContain('$ret_0');
+        expect(fn).toContain('__ns');
+    });
+});
+//# sourceMappingURL=tuple.test.js.map

package/dist/src/__tests__/typechecker-strict.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Phase 6b: TypeChecker strict (error-mode) tests
+ *
+ * Covers:
+ * - Type errors now block compilation (error-mode default)
+ * - --lenient flag demotes type errors to warnings
+ * - int/float implicit conversion detection
+ * - redscript check command correctly reports type errors
+ */
+export {};

package/dist/src/__tests__/typechecker-strict.test.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Phase 6b: TypeChecker strict (error-mode) tests
+ *
+ * Covers:
+ * - Type errors now block compilation (error-mode default)
+ * - --lenient flag demotes type errors to warnings
+ * - int/float implicit conversion detection
+ * - redscript check command correctly reports type errors
+ */
+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");
+// Helper: run TypeChecker directly
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const checker = new typechecker_1.TypeChecker(source);
+    return checker.check(ast);
+}
+// Helper: compile in strict mode (default)
+function compileStrict(source) {
+    (0, compile_1.compile)(source, { namespace: 'test' });
+}
+// Helper: compile in lenient mode
+function compileLenient(source) {
+    return (0, compile_1.compile)(source, { namespace: 'test', lenient: true });
+}
+describe('TypeChecker error-mode (Phase 6b)', () => {
+    describe('type errors block compilation', () => {
+        it('throws on undeclared variable usage', () => {
+            expect(() => compileStrict(`
+fn test() {
+    let x: int = undeclared;
+}
+`)).toThrow();
+        });
+        it('throws on return type mismatch', () => {
+            expect(() => compileStrict(`
+fn get_bool() -> bool {
+    return 5;
+}
+`)).toThrow();
+        });
+        it('throws on wrong argument count', () => {
+            expect(() => compileStrict(`
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+fn test() {
+    let x: int = add(1);
+}
+`)).toThrow();
+        });
+        it('does not throw for valid programs', () => {
+            expect(() => compileStrict(`
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+fn test() {
+    let x: int = add(1, 2);
+}
+`)).not.toThrow();
+        });
+    });
+    describe('--lenient mode', () => {
+        it('does not throw on type errors in lenient mode', () => {
+            expect(() => compileLenient(`
+fn test() {
+    let x: int = undeclared;
+}
+`)).not.toThrow();
+        });
+        it('returns type errors as warnings in lenient mode', () => {
+            const result = compileLenient(`
+fn test() {
+    let x: int = undeclared;
+}
+`);
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.warnings[0]).toContain('TypeError');
+        });
+        it('emits no warnings for valid programs in lenient mode', () => {
+            const result = compileLenient(`
+fn test() {
+    let x: int = 5;
+}
+`);
+            expect(result.warnings).toHaveLength(0);
+        });
+    });
+    describe('int/float implicit conversion checks', () => {
+        it('detects int assigned to float variable', () => {
+            // int literal assigned to float — different types
+            const errors = typeCheck(`
+fn test() {
+    let x: float = 5;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot implicitly convert int to float');
+            expect(errors[0].message).toContain('as float');
+        });
+        it('detects float assigned to int variable', () => {
+            const errors = typeCheck(`
+fn get_f() -> float {
+    return 3.14;
+}
+fn test() {
+    let x: int = get_f();
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot implicitly convert');
+        });
+        it('detects int/float return type mismatch', () => {
+            const errors = typeCheck(`
+fn get_float() -> float {
+    return 5;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot implicitly convert int to float');
+            expect(errors[0].message).toContain('as float');
+        });
+        it('detects float/int return type mismatch', () => {
+            const errors = typeCheck(`
+fn get_int() -> int {
+    return 3.14;
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot implicitly convert float to int');
+            expect(errors[0].message).toContain('as int');
+        });
+        it('allows int assigned to int variable', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 5;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('allows float assigned to float variable', () => {
+            const errors = typeCheck(`
+fn get_f() -> float {
+    return 3.14;
+}
+fn test() {
+    let x: float = get_f();
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('blocks compilation on int→float mismatch', () => {
+            expect(() => compileStrict(`
+fn get_float() -> float {
+    return 5;
+}
+`)).toThrow();
+        });
+        it('int→float mismatch demoted to warning in lenient mode', () => {
+            const result = compileLenient(`
+fn get_float() -> float {
+    return 5;
+}
+`);
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.warnings[0]).toContain('TypeError');
+        });
+    });
+    describe('redscript check command behavior', () => {
+        it('TypeChecker check() returns errors for type mismatches', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = undeclared;
+    let y: bool = 1;
+}
+`);
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+        });
+        it('TypeChecker check() returns empty array for valid programs', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+fn test() {
+    let p: Point = { x: 10, y: 20 };
+    let val: int = p.x;
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+    });
+});
+//# sourceMappingURL=typechecker-strict.test.js.map