redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/compile-preprocess.test.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * Branch coverage tests for src/compile.ts
+ *
+ * Targets uncovered branches in:
+ * - preprocessSourceWithMetadata: import without filePath, unresolvable import,
+ *   isLibrarySource detection, library vs non-library imports, resolveSourceLine,
+ *   offsetRanges, countLines
+ * - resolveImportPath: .mcrs extension, relative path, stdlib path, includeDirs
+ * - preprocessSource (wrapper)
+ */
+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("../compile");
+// ---------------------------------------------------------------------------
+// resolveSourceLine
+// ---------------------------------------------------------------------------
+describe('resolveSourceLine', () => {
+    const ranges = [
+        { startLine: 1, endLine: 10, filePath: 'a.mcrs' },
+        { startLine: 11, endLine: 20, filePath: 'b.mcrs' },
+    ];
+    test('maps line in first range to first file', () => {
+        const result = (0, compile_1.resolveSourceLine)(5, ranges);
+        expect(result.filePath).toBe('a.mcrs');
+        expect(result.line).toBe(5);
+    });
+    test('maps line in second range to second file', () => {
+        const result = (0, compile_1.resolveSourceLine)(15, ranges);
+        expect(result.filePath).toBe('b.mcrs');
+        expect(result.line).toBe(5);
+    });
+    test('line outside ranges uses fallback file', () => {
+        const result = (0, compile_1.resolveSourceLine)(99, ranges, 'fallback.mcrs');
+        expect(result.filePath).toBe('fallback.mcrs');
+        expect(result.line).toBe(99);
+    });
+    test('line outside ranges with no fallback', () => {
+        const result = (0, compile_1.resolveSourceLine)(99, ranges);
+        expect(result.filePath).toBeUndefined();
+        expect(result.line).toBe(99);
+    });
+    test('empty ranges uses fallback', () => {
+        const result = (0, compile_1.resolveSourceLine)(5, [], 'default.mcrs');
+        expect(result.filePath).toBe('default.mcrs');
+        expect(result.line).toBe(5);
+    });
+    test('boundary line (startLine) maps correctly', () => {
+        const result = (0, compile_1.resolveSourceLine)(1, ranges);
+        expect(result.filePath).toBe('a.mcrs');
+        expect(result.line).toBe(1);
+    });
+    test('boundary line (endLine) maps correctly', () => {
+        const result = (0, compile_1.resolveSourceLine)(10, ranges);
+        expect(result.filePath).toBe('a.mcrs');
+        expect(result.line).toBe(10);
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — basic (no imports)
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — no imports', () => {
+    test('simple source returns unchanged source', () => {
+        const result = (0, compile_1.preprocessSourceWithMetadata)('fn f() { }');
+        expect(result.source).toContain('fn f()');
+    });
+    test('empty source returns empty', () => {
+        const result = (0, compile_1.preprocessSourceWithMetadata)('');
+        expect(result.source).toBe('');
+        expect(result.ranges).toEqual([]);
+    });
+    test('returns no libraryImports when none present', () => {
+        const result = (0, compile_1.preprocessSourceWithMetadata)('fn f() { }');
+        expect(result.libraryImports).toBeUndefined();
+    });
+    test('includes filePath in ranges when provided', () => {
+        const result = (0, compile_1.preprocessSourceWithMetadata)('fn f() { }', { filePath: 'test.mcrs' });
+        expect(result.ranges.length).toBeGreaterThan(0);
+        expect(result.ranges[0].filePath).toContain('test.mcrs');
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — import without filePath throws
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — import without filePath', () => {
+    test('throws ParseError when import used without filePath', () => {
+        const source = `import "stdlib/math";
+fn f(): int { return 1; }
+`;
+        expect(() => (0, compile_1.preprocessSourceWithMetadata)(source)).toThrow(/ParseError|Import statements require/);
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — unresolvable import
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — unresolvable import', () => {
+    test('throws ParseError when import path cannot be resolved', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-test-'));
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(mainFile, `import "nonexistent_module_xyz";\nfn f(): int { return 1; }\n`);
+        try {
+            expect(() => (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile })).toThrow(/Cannot import|nonexistent_module_xyz/);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — library source detection
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — library source', () => {
+    test('isLibrarySource: module library at top is recognized as library', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-lib-'));
+        const libFile = path.join(tmpDir, 'mylib.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(libFile, `module library;\nfn lib_fn(): int { return 42; }\n`);
+        fs.writeFileSync(mainFile, `import "mylib";\nfn main(): int { return lib_fn(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            // Library imports should be collected separately
+            expect(result.libraryImports).toBeDefined();
+            expect(result.libraryImports.length).toBeGreaterThan(0);
+            expect(result.libraryImports[0].source).toContain('module library');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+    test('isLibrarySource: source with only comments before module library', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-lib2-'));
+        const libFile = path.join(tmpDir, 'commented_lib.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        // Comments before module declaration
+        fs.writeFileSync(libFile, `// This is a library\n// Usage: import this\n\nmodule library;\nfn helper(): int { return 1; }\n`);
+        fs.writeFileSync(mainFile, `import "commented_lib";\nfn main(): int { return helper(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            expect(result.libraryImports).toBeDefined();
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+    test('non-library import is concatenated into source', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-nolib-'));
+        const modFile = path.join(tmpDir, 'helpers.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        // No "module library" declaration
+        fs.writeFileSync(modFile, `fn helper(): int { return 99; }\n`);
+        fs.writeFileSync(mainFile, `import "helpers";\nfn main(): int { return helper(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            // Should be concatenated (no libraryImports)
+            expect(result.libraryImports).toBeUndefined();
+            expect(result.source).toContain('fn helper()');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — stdlib import
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — stdlib imports', () => {
+    test('stdlib/math import resolves correctly', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-stdlib-'));
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(mainFile, `import "stdlib/math";\nfn f(): int { return abs(-5); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            // math.mcrs is a library, so it goes to libraryImports
+            expect(result.libraryImports).toBeDefined();
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — includeDirs
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — includeDirs', () => {
+    test('includeDirs resolves imports from extra directories', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-extra-'));
+        const extraDir = path.join(tmpDir, 'extra');
+        fs.mkdirSync(extraDir);
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        const libFile = path.join(extraDir, 'custom_lib.mcrs');
+        fs.writeFileSync(libFile, `fn custom(): int { return 77; }\n`);
+        fs.writeFileSync(mainFile, `import "custom_lib";\nfn f(): int { return custom(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile, includeDirs: [extraDir] });
+            expect(result.source).toContain('fn custom()');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — duplicate import deduplication
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — deduplication', () => {
+    test('same file imported twice is only included once', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-dup-'));
+        const libFile = path.join(tmpDir, 'dup.mcrs');
+        const mod1File = path.join(tmpDir, 'mod1.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(libFile, `fn shared(): int { return 1; }\n`);
+        fs.writeFileSync(mod1File, `import "dup";\nfn from_mod1(): int { return shared(); }\n`);
+        fs.writeFileSync(mainFile, `import "dup";\nimport "mod1";\nfn main(): int { return from_mod1(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            // dup.mcrs should only appear once in source
+            const dupCount = (result.source.match(/fn shared\(\)/g) ?? []).length;
+            expect(dupCount).toBe(1);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — .mcrs extension handling
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — extension handling', () => {
+    test('import with explicit .mcrs extension resolves', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-ext-'));
+        const libFile = path.join(tmpDir, 'withext.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(libFile, `fn ext_fn(): int { return 5; }\n`);
+        fs.writeFileSync(mainFile, `import "withext.mcrs";\nfn f(): int { return ext_fn(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            expect(result.source).toContain('fn ext_fn()');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — ranges include library transitive imports
+// ---------------------------------------------------------------------------
+describe('preprocessSourceWithMetadata — transitive library imports', () => {
+    test('transitive library imports are collected', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-trans-'));
+        const innerLib = path.join(tmpDir, 'inner.mcrs');
+        const outerLib = path.join(tmpDir, 'outer.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(innerLib, `module library;\nfn inner(): int { return 1; }\n`);
+        fs.writeFileSync(outerLib, `module library;\nimport "inner";\nfn outer(): int { return inner(); }\n`);
+        fs.writeFileSync(mainFile, `import "outer";\nfn main(): int { return outer(); }\n`);
+        try {
+            const result = (0, compile_1.preprocessSourceWithMetadata)(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile });
+            // Both library files should be collected
+            expect(result.libraryImports).toBeDefined();
+            expect(result.libraryImports.length).toBeGreaterThanOrEqual(1);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// preprocessSource (wrapper)
+// ---------------------------------------------------------------------------
+describe('preprocessSource', () => {
+    test('returns source string same as preprocessSourceWithMetadata.source', () => {
+        const source = 'fn f(): int { return 0; }';
+        const result = (0, compile_1.preprocessSource)(source);
+        const meta = (0, compile_1.preprocessSourceWithMetadata)(source);
+        expect(result).toBe(meta.source);
+    });
+    test('accepts options', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-wrap-'));
+        const libFile = path.join(tmpDir, 'wraplib.mcrs');
+        const mainFile = path.join(tmpDir, 'main.mcrs');
+        fs.writeFileSync(libFile, `fn wrap(): int { return 7; }\n`);
+        fs.writeFileSync(mainFile, `import "wraplib";\nfn f(): int { return wrap(); }\n`);
+        try {
+            const source = fs.readFileSync(mainFile, 'utf-8');
+            const result = (0, compile_1.preprocessSource)(source, { filePath: mainFile });
+            expect(result).toContain('fn wrap()');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});
+//# sourceMappingURL=compile-preprocess.test.js.map

package/dist/src/__tests__/compiler/break-stmt.test.d.ts

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

package/dist/src/__tests__/compiler/break-stmt.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+const SOURCE = `
+  fn test_break() {
+    let i: int = 0
+    while i < 10 {
+      if i == 5 { break }
+      i = i + 1
+    }
+    // i should be 5
+  }
+`;
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+function lowerFn(source) {
+    const ast = parse(source);
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    const mir = (0, lower_2.lowerToMIR)(hir);
+    expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+    return mir.functions.find(fn => fn.name === 'test_break');
+}
+describe('break statement', () => {
+    test('parser recognizes break inside while', () => {
+        const ast = parse(SOURCE);
+        const whileStmt = ast.declarations[0].body[1];
+        expect(whileStmt.kind).toBe('while');
+        if (whileStmt.kind !== 'while')
+            throw new Error('expected while statement');
+        const ifStmt = whileStmt.body[0];
+        expect(ifStmt.kind).toBe('if');
+        if (ifStmt.kind !== 'if')
+            throw new Error('expected if statement');
+        expect(ifStmt.then[0]).toMatchObject({ kind: 'break' });
+    });
+    test('MIR lowering turns break into jump to loop exit block', () => {
+        const fn = lowerFn(SOURCE);
+        const exitBlock = fn.blocks.find(block => block.id.startsWith('loop_exit'));
+        expect(exitBlock).toBeDefined();
+        const breakJump = fn.blocks.find(block => block.term.kind === 'jump' &&
+            block.term.target === exitBlock.id &&
+            !block.id.startsWith('loop_header') &&
+            !block.id.startsWith('loop_exit') &&
+            !block.id.startsWith('entry'));
+        expect(breakJump).toBeDefined();
+    });
+    test('end-to-end compile accepts while break program', () => {
+        expect(() => (0, compile_1.compile)(SOURCE, { namespace: 'test' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=break-stmt.test.js.map

package/dist/src/__tests__/compiler/const-decl.test.d.ts

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

package/dist/src/__tests__/compiler/const-decl.test.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+// ---------------------------------------------------------------------------
+// Top-level const declarations
+// ---------------------------------------------------------------------------
+const TOP_LEVEL_CONST_SOURCE = `
+  const MAX_HEALTH: int = 20
+  const PI_APPROX: int = 31416
+
+  fn test() {
+    let h = MAX_HEALTH
+    let pi = PI_APPROX
+  }
+`;
+describe('top-level const declarations', () => {
+    test('parser collects consts into program.consts', () => {
+        const ast = parse(TOP_LEVEL_CONST_SOURCE);
+        expect(ast.consts).toHaveLength(2);
+        expect(ast.consts[0].name).toBe('MAX_HEALTH');
+        expect(ast.consts[0].value).toMatchObject({ kind: 'int_lit', value: 20 });
+        expect(ast.consts[1].name).toBe('PI_APPROX');
+        expect(ast.consts[1].value).toMatchObject({ kind: 'int_lit', value: 31416 });
+    });
+    test('HIR preserves consts array', () => {
+        const ast = parse(TOP_LEVEL_CONST_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        expect(hir.consts).toHaveLength(2);
+        expect(hir.consts[0].name).toBe('MAX_HEALTH');
+    });
+    test('MIR inlines constants at use sites — copy src is a const operand', () => {
+        const ast = parse(TOP_LEVEL_CONST_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+        const fn = mir.functions.find(f => f.name === 'test');
+        expect(fn).toBeDefined();
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // When MAX_HEALTH / PI_APPROX are referenced, a copy instr is emitted with a const operand src
+        const copyConstSrcs = allInstrs
+            .filter(i => i.kind === 'copy' && i.src.kind === 'const')
+            .map(i => i.src.value);
+        expect(copyConstSrcs).toContain(20);
+        expect(copyConstSrcs).toContain(31416);
+    });
+    test('end-to-end compile accepts const declarations', () => {
+        expect(() => (0, compile_1.compile)(TOP_LEVEL_CONST_SOURCE, { namespace: 'test' })).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// Local (function-body) const declarations
+// ---------------------------------------------------------------------------
+const LOCAL_CONST_SOURCE = `
+  fn compute() {
+    const FACTOR: int = 100
+    let result = FACTOR
+  }
+`;
+describe('local const declarations (inside function)', () => {
+    test('parser produces const_decl stmt in function body', () => {
+        const ast = parse(LOCAL_CONST_SOURCE);
+        const fn = ast.declarations[0];
+        expect(fn.body[0]).toMatchObject({ kind: 'const_decl', name: 'FACTOR' });
+    });
+    test('HIR preserves const_decl stmt', () => {
+        const ast = parse(LOCAL_CONST_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const fn = hir.functions[0];
+        expect(fn.body[0]).toMatchObject({ kind: 'const_decl', name: 'FACTOR' });
+    });
+    test('MIR inlines local constant at use sites', () => {
+        const ast = parse(LOCAL_CONST_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+        const fn = mir.functions.find(f => f.name === 'compute');
+        expect(fn).toBeDefined();
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // FACTOR=100 is inlined at the use site as a const operand in a copy instruction
+        const copyConstSrcs = allInstrs
+            .filter(i => i.kind === 'copy' && i.src.kind === 'const')
+            .map(i => i.src.value);
+        expect(copyConstSrcs).toContain(100);
+    });
+    test('end-to-end compile accepts local const', () => {
+        expect(() => (0, compile_1.compile)(LOCAL_CONST_SOURCE, { namespace: 'test' })).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// Bool const
+// ---------------------------------------------------------------------------
+const BOOL_CONST_SOURCE = `
+  const FLAG: bool = true
+
+  fn check() {
+    let f = FLAG
+  }
+`;
+describe('bool const declarations', () => {
+    test('bool const is inlined as 1', () => {
+        const ast = parse(BOOL_CONST_SOURCE);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+        const fn = mir.functions.find(f => f.name === 'check');
+        expect(fn).toBeDefined();
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const copyConstSrcs = allInstrs
+            .filter(i => i.kind === 'copy' && i.src.kind === 'const')
+            .map(i => i.src.value);
+        expect(copyConstSrcs).toContain(1);
+    });
+});
+//# sourceMappingURL=const-decl.test.js.map

package/dist/src/__tests__/compiler/continue-stmt.test.d.ts

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

package/dist/src/__tests__/compiler/continue-stmt.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+const SOURCE = `
+  fn test_continue() {
+    let sum: int = 0
+    let i: int = 0
+    while (i < 10) {
+      i = i + 1
+      if (i % 2 == 0) { continue }
+      sum = sum + i
+    }
+  }
+`;
+function parse(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens).parse(namespace);
+}
+function compileMIR(source) {
+    const ast = parse(source);
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    return (0, lower_2.lowerToMIR)(hir);
+}
+function getFn(mod, name) {
+    if (name)
+        return mod.functions.find(f => f.name === name);
+    return mod.functions[0];
+}
+describe('continue statement', () => {
+    test('parser builds continue AST node inside while body', () => {
+        const program = parse(SOURCE);
+        const whileStmt = program.declarations[0].body[2];
+        expect(whileStmt.kind).toBe('while');
+        if (whileStmt.kind !== 'while') {
+            throw new Error('expected while statement');
+        }
+        const ifStmt = whileStmt.body[1];
+        expect(ifStmt.kind).toBe('if');
+        if (ifStmt.kind !== 'if') {
+            throw new Error('expected if statement');
+        }
+        expect(ifStmt.then[0]).toMatchObject({ kind: 'continue' });
+    });
+    test('MIR lowers continue to a jump back to loop header', () => {
+        const mod = compileMIR(SOURCE);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod, 'test_continue');
+        const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header'));
+        expect(headerBlock).toBeDefined();
+        const continueBlock = fn.blocks.find(b => b.term.kind === 'jump' &&
+            b.term.target === headerBlock.id &&
+            !b.id.startsWith('loop_header') &&
+            !b.id.startsWith('entry'));
+        expect(continueBlock).toBeDefined();
+    });
+    test('full compiler pipeline accepts while + continue program', () => {
+        const result = (0, compile_1.compile)(SOURCE, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        expect(result.files.some(f => f.path.endsWith('function/test_continue.mcfunction'))).toBe(true);
+    });
+});
+//# sourceMappingURL=continue-stmt.test.js.map

package/dist/src/__tests__/compiler/coroutine-extended.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Extended tests for the coroutine transform pass.
+ *
+ * Covers edge cases and code paths not exercised by the basic coroutine tests:
+ * - Post-loop continuation blocks (after loop exit)
+ * - Multiple @coroutine functions in one module
+ * - buildDispatcher with 0 continuations (empty list)
+ * - buildInitFunction with copy & fallback promoted var init
+ * - rewriteInstr: neg, not, nbt_read, nbt_read_dynamic, nbt_write, nbt_write_dynamic,
+ *   score_read, score_write, call_macro, call_context, return with value
+ * - rewriteTerminator (jump, branch, default)
+ * - buildLoopContinuation exit-block redirect branches (!thenInLoop && elseInLoop)
+ * - intersect idom fallback in dominator computation
+ * - getUsedTemps for nbt_write, nbt_write_dynamic, return with value
+ * - @coroutine function with both a loop AND post-loop blocks
+ */
+export {};