redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/diagnostics-extra.test.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Extra coverage for src/diagnostics/index.ts
+ * Targets uncovered branches: formatSourcePointer edge cases, formatError paths,
+ * parseErrorMessage, DiagnosticCollector.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const diagnostics_1 = require("../diagnostics");
+describe('DiagnosticError — format()', () => {
+    test('formats without sourceLines', () => {
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'unexpected token', { line: 5, col: 3 });
+        const formatted = err.format();
+        expect(formatted).toContain('[ParseError]');
+        expect(formatted).toContain('line 5');
+        expect(formatted).toContain('col 3');
+        expect(formatted).toContain('unexpected token');
+    });
+    test('formats with file path', () => {
+        const err = new diagnostics_1.DiagnosticError('LexError', 'bad char', { file: 'foo.mcrs', line: 2, col: 1 });
+        const formatted = err.format();
+        expect(formatted).toContain('foo.mcrs');
+    });
+    test('formats with sourceLines and shows pointer', () => {
+        const source = ['let x = 42', 'let y = @'];
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'unexpected @', { line: 2, col: 9 }, source);
+        const formatted = err.format();
+        expect(formatted).toContain('let y = @');
+        expect(formatted).toContain('^');
+    });
+    test('format with out-of-range line returns just header', () => {
+        const source = ['only one line'];
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'bad', { line: 99, col: 1 }, source);
+        const formatted = err.format();
+        expect(formatted).toContain('[ParseError]');
+        // out-of-range line → no source pointer
+        expect(formatted).not.toContain('only one line');
+    });
+    test('format with col beyond line length clips safely', () => {
+        const source = ['abc'];
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'bad', { line: 1, col: 100 }, source);
+        const formatted = err.format();
+        expect(formatted).toContain('abc');
+    });
+    test('toString() delegates to format()', () => {
+        const err = new diagnostics_1.DiagnosticError('TypeError', 'type mismatch', { line: 1, col: 1 });
+        expect(err.toString()).toBe(err.format());
+    });
+    test('format hint appears for "expected" messages', () => {
+        const source = ['let x = 42'];
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'expected: semicolon', { line: 1, col: 10 }, source);
+        const formatted = err.format();
+        expect(formatted).toContain('semicolon');
+    });
+});
+describe('DiagnosticCollector', () => {
+    test('hasErrors false initially', () => {
+        const collector = new diagnostics_1.DiagnosticCollector();
+        expect(collector.hasErrors()).toBe(false);
+    });
+    test('error() adds diagnostics', () => {
+        const collector = new diagnostics_1.DiagnosticCollector('let x = @\n', 'test.mcrs');
+        collector.error('ParseError', 'bad char', 1, 9);
+        expect(collector.hasErrors()).toBe(true);
+        expect(collector.getErrors()).toHaveLength(1);
+    });
+    test('formatAll() returns formatted string', () => {
+        const collector = new diagnostics_1.DiagnosticCollector('let x = @\n');
+        collector.error('ParseError', 'bad char', 1, 9);
+        const text = collector.formatAll();
+        expect(text).toContain('[ParseError]');
+    });
+    test('throwFirst() throws the first diagnostic', () => {
+        const collector = new diagnostics_1.DiagnosticCollector();
+        collector.error('TypeError', 'type mismatch', 1, 1);
+        expect(() => collector.throwFirst()).toThrow(diagnostics_1.DiagnosticError);
+    });
+    test('throwFirst() throws generic error if no diagnostics', () => {
+        const collector = new diagnostics_1.DiagnosticCollector();
+        expect(() => collector.throwFirst()).toThrow('No diagnostics to throw');
+    });
+});
+describe('parseErrorMessage', () => {
+    test('extracts line/col from message', () => {
+        const err = (0, diagnostics_1.parseErrorMessage)('ParseError', 'unexpected token at line 5, col 12');
+        expect(err.location.line).toBe(5);
+        expect(err.location.col).toBe(12);
+        expect(err.message).toBe('unexpected token');
+    });
+    test('falls back to line 1, col 1 when no match', () => {
+        const err = (0, diagnostics_1.parseErrorMessage)('LexError', 'something went wrong');
+        expect(err.location.line).toBe(1);
+        expect(err.location.col).toBe(1);
+        expect(err.message).toBe('something went wrong');
+    });
+    test('passes filePath and sourceLines through', () => {
+        const sourceLines = ['let x = 42'];
+        const err = (0, diagnostics_1.parseErrorMessage)('TypeError', 'bad at line 1, col 1', sourceLines, 'foo.mcrs');
+        expect(err.location.file).toBe('foo.mcrs');
+        expect(err.sourceLines).toBe(sourceLines);
+    });
+});
+describe('formatError', () => {
+    test('formats DiagnosticError with source override', () => {
+        const source = 'let x = 42\n';
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'bad', { line: 1, col: 9 });
+        const formatted = (0, diagnostics_1.formatError)(err, source, 'test.mcrs');
+        expect(formatted).toContain('test.mcrs');
+        expect(formatted).toContain('let x = 42');
+    });
+    test('formats DiagnosticError without source (uses error.sourceLines)', () => {
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'bad', { line: 1, col: 9 }, ['let x = 42']);
+        const formatted = (0, diagnostics_1.formatError)(err);
+        expect(formatted).toContain('let x = 42');
+    });
+    test('formats DiagnosticError without any source lines', () => {
+        const err = new diagnostics_1.DiagnosticError('ParseError', 'bad', { line: 1, col: 1 });
+        const formatted = (0, diagnostics_1.formatError)(err);
+        expect(formatted).toContain('bad');
+    });
+    test('formats generic Error without source', () => {
+        const err = new Error('something failed');
+        const formatted = (0, diagnostics_1.formatError)(err);
+        expect(formatted).toContain('something failed');
+    });
+    test('formats generic Error with source (falls back to parseErrorMessage)', () => {
+        const err = new Error('unexpected token at line 2, col 5');
+        const source = 'let x = 1\nlet y = @\n';
+        const formatted = (0, diagnostics_1.formatError)(err, source, 'foo.mcrs');
+        expect(formatted).toContain('foo.mcrs');
+    });
+});
+//# sourceMappingURL=diagnostics-extra.test.js.map

package/dist/src/__tests__/emit/compile-branches.test.d.ts

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

package/dist/src/__tests__/emit/compile-branches.test.js

@@ -0,0 +1,123 @@
+"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 compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    return files.find(f => f.path.includes(pathSubstr))?.content;
+}
+describe('emit/compile branch coverage', () => {
+    test('resolves whole-module imports from includeDirs, recurses nested imports, and deduplicates repeats', () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'emit-compile-'));
+        const includeDir = path.join(tempDir, 'libs');
+        fs.mkdirSync(includeDir, { recursive: true });
+        const mainPath = path.join(tempDir, 'main.mcrs');
+        const utilPath = path.join(includeDir, 'util.mcrs');
+        const nestedPath = path.join(includeDir, 'nested.mcrs');
+        fs.writeFileSync(mainPath, [
+            'import util;',
+            'import util;',
+            'fn main(): int {',
+            '  return helper() + nested_value();',
+            '}',
+            '',
+        ].join('\n'));
+        fs.writeFileSync(utilPath, [
+            'import nested;',
+            'fn helper(): int { return 1; }',
+            '',
+        ].join('\n'));
+        fs.writeFileSync(nestedPath, [
+            'import missing_dep;',
+            'fn nested_value(): int { return 2; }',
+            '',
+        ].join('\n'));
+        const result = (0, compile_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'emit_files',
+            filePath: mainPath,
+            includeDirs: [includeDir],
+        });
+        expect(result.warnings).toContain(`[ImportWarning] Module 'missing_dep' not found (imported in ${nestedPath})`);
+        expect(result.files.filter(file => file.path.includes('helper.mcfunction'))).toHaveLength(1);
+        expect(result.files.filter(file => file.path.includes('nested_value.mcfunction'))).toHaveLength(1);
+        expect(getFile(result.files, 'main.mcfunction')).toContain('function emit_files:helper');
+    });
+    test('throws a diagnostic when a whole-module import cannot be resolved', () => {
+        expect(() => (0, compile_1.compile)('import nope;\nfn main(): int { return 0; }\n', {
+            namespace: 'emit_missing_mod',
+            filePath: path.join(os.tmpdir(), 'emit-missing-main.mcrs'),
+        })).toThrow(/Module 'nope' not found/);
+    });
+    test('merges library file imports and inline librarySources', () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'emit-library-'));
+        const mainPath = path.join(tempDir, 'main.mcrs');
+        const libPath = path.join(tempDir, 'helpers.mcrs');
+        fs.writeFileSync(mainPath, [
+            'import "helpers";',
+            'fn main(): int {',
+            '  return from_file() + from_inline();',
+            '}',
+            '',
+        ].join('\n'));
+        fs.writeFileSync(libPath, [
+            'module library;',
+            'fn from_file(): int { return 40; }',
+            '',
+        ].join('\n'));
+        const result = (0, compile_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'emit_library',
+            filePath: mainPath,
+            librarySources: ['module library;\nfn from_inline(): int { return 2; }\n'],
+        });
+        expect(getFile(result.files, 'main.mcfunction')).toContain('function emit_library:from_file');
+        expect(getFile(result.files, 'main.mcfunction')).toContain('function emit_library:from_inline');
+        expect(result.files.some(file => file.path.includes('from_file.mcfunction'))).toBe(true);
+        expect(result.files.some(file => file.path.includes('from_inline.mcfunction'))).toBe(true);
+    });
+    test('lenient mode demotes type errors into warnings', () => {
+        const result = (0, compile_1.compile)([
+            'fn main(): int {',
+            '  let bad: int = true;',
+            '  return 0;',
+            '}',
+            '',
+        ].join('\n'), { namespace: 'emit_lenient', lenient: true });
+        expect(result.warnings.some(warning => warning.startsWith('[TypeError]'))).toBe(true);
+        expect(result.files.some(file => file.path.includes('main.mcfunction'))).toBe(true);
+    });
+});
+//# sourceMappingURL=compile-branches.test.js.map

package/dist/src/__tests__/emit/compile-coverage.test.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Targeted branch-coverage tests for src/emit/compile.ts and src/emit/modules.ts.
+ *
+ * Focus areas:
+ *   compile.ts:
+ *     - stopAfterCheck + various error sources (parse, library, librarySources, type)
+ *     - @watch decorator fallback path (watchObjective not propagated)
+ *     - budget diagnostics with level 'error'
+ *     - INT32 overflow warning path
+ *     - catch block branches (CheckFailedError, DiagnosticBundleError, DiagnosticError)
+ *
+ *   modules.ts:
+ *     - parse error in module input
+ *     - whole-module (undefined symbol) import in importMap building
+ *     - whole-module import and wildcard in usedExports computation
+ *     - !used branch (imported module not in usedExports map)
+ *     - C-style for stmt (case 'for') in rewriteStmt
+ *     - for stmt without init (stmt.init is undefined)
+ *     - match arm without PatExpr pattern
+ *     - unary expr (arm 3 in rewriteExpr switch)
+ *     - invoke expr (arm 10 in rewriteExpr switch)
+ *     - @watch in compileSingleModule
+ *     - catch block in compileSingleModule
+ */
+export {};