redscript-mc 1.0.0

package/README.zh.md

@@ -0,0 +1,261 @@
+<div align="center">
+
+<img src="https://img.shields.io/badge/RedScript-1.0-red?style=for-the-badge&logo=minecraft&logoColor=white" alt="RedScript" />
+
+**一个编译到 Minecraft Datapack 的类型化脚本语言。**
+
+写干净的游戏逻辑，把记分板的面条代码交给 RedScript 处理。
+
+[![CI](https://github.com/bkmashiro/redscript/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/bkmashiro/redscript/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/redscript-mc?color=cb3837)](https://www.npmjs.com/package/redscript-mc)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+[![tests](https://img.shields.io/badge/tests-423%20passing-brightgreen)](./src/__tests__)
+
+[English](./README.md) · [Wiki](https://github.com/bkmashiro/redscript/wiki) · [快速开始](#快速开始)
+
+</div>
+
+---
+
+### RedScript 是什么？
+
+你想做一个 Minecraft 小游戏——倒计时、击杀计数、复活逻辑、记分板显示。用原版 MC 的话，这意味着 40+ 个 `.mcfunction` 文件、几百条 `execute if score` 命令，还要花一个周末调试。
+
+用 RedScript，就是这样：
+
+```rs
+// pvp_game.rs
+import "stdlib/player.rs"
+
+const GAME_TIME: int = 300;
+
+@tick(rate=20)
+fn every_second() {
+    let time: int = scoreboard_get(#game, #timer);
+
+    if (time <= 0) {
+        end_game();
+        return;
+    }
+
+    scoreboard_set(#game, #timer, time - 1);
+    actionbar(@a, "⏱ 剩余 ${time} 秒");
+}
+
+fn start_game() {
+    scoreboard_set(#game, #timer, GAME_TIME);
+    scoreboard_set(#game, #running, 1);
+    title(@a, "开始战斗！", "游戏已开始");
+    tp(@a, (0, 64, 0));
+}
+
+fn end_game() {
+    scoreboard_set(#game, #running, 0);
+    title(@a, "游戏结束！");
+    announce("感谢游玩！");
+}
+
+@on_death
+fn on_kill() {
+    scoreboard_add(@s, #kills, 1);
+}
+```
+
+一个文件，几秒钟编译出可以直接用的 datapack。
+
+---
+
+### 快速开始
+
+#### 安装
+
+```bash
+npm install -g redscript
+```
+
+#### 编译
+
+```bash
+redscript compile pvp_game.rs -o ./my-datapack
+```
+
+```
+✓ 已编译 pvp_game.rs
+  命名空间 : pvp_game
+  函数数量  : 7
+  命令数量  : 34  →  28  (优化器节省了 18%)
+  输出目录  : ./my-datapack/
+```
+
+#### 部署
+
+把输出文件夹丢进存档的 `datapacks/` 目录，游戏内跑 `/reload`，完成。
+
+---
+
+### 语言特性
+
+#### 变量与类型
+
+```rs
+let x: int = 42;
+let name: string = "Steve";
+let spawn: BlockPos = (0, 64, 0);
+let nearby: BlockPos = (~5, ~0, ~5);   // 相对坐标
+const MAX: int = 100;                  // 编译期常量
+```
+
+#### MC 名称（Objective / Tag / Team）
+
+用 `#name` 表示 Minecraft 标识符，不需要引号：
+
+```rs
+// Objective、fake player、tag、team 名都不用引号
+let hp: int = scoreboard_get(@s, #health);
+scoreboard_set(#game, #timer, 300);      // fake player #game，objective timer
+tag_add(@s, #hasKey);
+team_join(#red, @s);
+gamerule(#keepInventory, true);
+
+// 字符串仍然兼容（向后兼容）
+scoreboard_get(@s, "health")             // 和 #health 编译结果相同
+```
+
+#### 函数与默认参数
+
+```rs
+fn greet(player: selector, msg: string = "欢迎！") {
+    tell(player, msg);
+}
+
+greet(@s);              // 使用默认消息
+greet(@a, "你好！");    // 覆盖默认值
+```
+
+#### 装饰器
+
+```rs
+@tick                  // 每 tick 执行
+fn heartbeat() { ... }
+
+@tick(rate=20)         // 每秒执行一次
+fn every_second() { ... }
+
+@on_advancement("story/mine_diamond")
+fn on_diamond() {
+    give(@s, "minecraft:diamond", 5);
+}
+
+@on_death
+fn on_death() {
+    scoreboard_add(@s, #deaths, 1);
+}
+```
+
+#### 控制流
+
+```rs
+if (hp <= 0) {
+    respawn();
+} else if (hp < 5) {
+    warn_player();
+}
+
+for (let i: int = 0; i < 10; i = i + 1) {
+    summon("minecraft:zombie", (i, 64, 0));
+}
+
+foreach (player in @a) {
+    heal(player, 2);
+}
+```
+
+#### 结构体与枚举
+
+```rs
+enum Phase { Lobby, Playing, Ended }
+
+struct Player {
+    score: int,
+    alive: bool,
+}
+
+match (phase) {
+    Phase::Lobby   => { announce("等待玩家..."); }
+    Phase::Playing => { every_second(); }
+    Phase::Ended   => { show_scoreboard(); }
+}
+```
+
+#### Lambda
+
+```rs
+fn apply(f: (int) -> int, x: int) -> int {
+    return f(x);
+}
+
+let double = (x: int) -> int { return x * 2; };
+apply(double, 5);  // 10
+```
+
+#### 数组
+
+```rs
+let scores: int[] = [];
+push(scores, 42);
+
+foreach (s in scores) {
+    announce("得分：${s}");
+}
+```
+
+---
+
+### CLI 参考
+
+```
+redscript compile <file>       编译为 datapack（默认）或 structure
+  -o, --output <dir>           输出目录              [默认: ./out]
+  --target datapack|structure  输出格式              [默认: datapack]
+  --namespace <ns>             Datapack 命名空间     [默认: 文件名]
+  --no-optimize                禁用优化器
+  --stats                      输出优化器统计信息
+
+redscript repl                 启动交互式 REPL
+redscript validate <file>      验证 MC 命令语法
+```
+
+---
+
+### 标准库
+
+```rs
+import "stdlib/math.rs"       // abs, min, max, clamp
+import "stdlib/player.rs"     // is_alive, in_range, get_health
+import "stdlib/timer.rs"      // start_timer, tick_timer, has_elapsed
+import "stdlib/cooldown.rs"   // set_cooldown, check_cooldown
+import "stdlib/mobs.rs"       // ZOMBIE, SKELETON, CREEPER ... (60+ 实体常量)
+```
+
+---
+
+### 更多文档
+
+| | |
+|---|---|
+| 📖 [语言参考](docs/LANGUAGE_REFERENCE.md) | 完整语法与类型系统 |
+| 🔧 [内置函数](https://github.com/bkmashiro/redscript/wiki/Builtins) | 所有 34+ MC 内置函数 |
+| ⚡ [优化器](https://github.com/bkmashiro/redscript/wiki/Optimizer) | 各优化 Pass 说明 |
+| 🧱 [结构体目标](docs/STRUCTURE_TARGET.md) | 编译到 NBT 命令方块结构体 |
+| 🧪 [集成测试](https://github.com/bkmashiro/redscript/wiki/Integration-Testing) | 在真实 Paper 服务器上测试 |
+| 🏗 [实现指南](docs/IMPLEMENTATION_GUIDE.md) | 编译器内部原理 |
+
+---
+
+<div align="center">
+
+MIT License · Copyright © 2026 [bkmashiro](https://github.com/bkmashiro)
+
+*少写一点，多做一些，更快交付。*
+
+</div>

package/dist/__tests__/cli.test.d.ts

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

package/dist/__tests__/cli.test.js

@@ -0,0 +1,140 @@
+"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 index_1 = require("../index");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+// Note: watch command is tested manually as it's an interactive long-running process
+describe('CLI API', () => {
+    describe('imports', () => {
+        it('compiles a file with imported helpers', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'));
+            const libPath = path.join(tempDir, 'lib.rs');
+            const mainPath = path.join(tempDir, 'main.rs');
+            fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n');
+            fs.writeFileSync(mainPath, 'import "./lib.rs"\n\nfn main() { let value: int = double(2); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'imports', filePath: mainPath });
+            expect(result.files.length).toBeGreaterThan(0);
+            expect(result.ir.functions.some(fn => fn.name === 'double')).toBe(true);
+            expect(result.ir.functions.some(fn => fn.name === 'main')).toBe(true);
+        });
+        it('deduplicates circular imports', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'));
+            const aPath = path.join(tempDir, 'a.rs');
+            const bPath = path.join(tempDir, 'b.rs');
+            const mainPath = path.join(tempDir, 'main.rs');
+            fs.writeFileSync(aPath, 'import "./b.rs"\n\nfn from_a() -> int { return 1; }\n');
+            fs.writeFileSync(bPath, 'import "./a.rs"\n\nfn from_b() -> int { return from_a(); }\n');
+            fs.writeFileSync(mainPath, 'import "./a.rs"\n\nfn main() { let value: int = from_b(); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'circular', filePath: mainPath });
+            expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1);
+            expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1);
+        });
+    });
+    describe('compile()', () => {
+        it('compiles simple source', () => {
+            const source = 'fn test() { say("hello"); }';
+            const result = (0, index_1.compile)(source, { namespace: 'mypack' });
+            expect(result.files.length).toBeGreaterThan(0);
+            expect(result.ast.namespace).toBe('mypack');
+            expect(result.ir.functions.length).toBe(1);
+        });
+        it('uses default namespace', () => {
+            const source = 'fn test() {}';
+            const result = (0, index_1.compile)(source);
+            expect(result.ast.namespace).toBe('redscript');
+        });
+        it('generates correct file structure', () => {
+            const source = 'fn test() { say("hello"); }';
+            const result = (0, index_1.compile)(source, { namespace: 'game' });
+            const paths = result.files.map(f => f.path);
+            expect(paths).toContain('pack.mcmeta');
+            expect(paths).toContain('data/game/function/__load.mcfunction');
+            expect(paths.some(p => p.includes('test.mcfunction'))).toBe(true);
+        });
+        it('collects optimizer stats', () => {
+            const source = `
+fn build() {
+  foreach (turret in @e[tag=turret]) {
+    let range: int = scoreboard_get("config", "turret_range");
+    if (range > 0) {
+      if (range > -1) {
+        say("ready");
+      }
+    }
+  }
+}
+`;
+            const result = (0, index_1.compile)(source, { namespace: 'stats' });
+            expect(result.stats?.licmHoists).toBeGreaterThan(0);
+            expect(result.stats?.totalCommandsBefore).toBeGreaterThan(result.stats?.totalCommandsAfter ?? 0);
+            expect(result.stats?.deadCodeRemoved).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('--stats flag', () => {
+        it('prints optimizer statistics', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'));
+            const inputPath = path.join(tempDir, 'input.rs');
+            const outputDir = path.join(tempDir, 'out');
+            fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }');
+            const stdout = (0, child_process_1.execFileSync)(process.execPath, ['-r', 'ts-node/register', path.join(process.cwd(), 'src/cli.ts'), 'compile', inputPath, '-o', outputDir, '--stats'], { cwd: process.cwd(), encoding: 'utf-8' });
+            expect(stdout).toContain('Optimizations applied:');
+            expect(stdout).toContain('setblock batching:');
+            expect(stdout).toContain('Total mcfunction commands:');
+        });
+    });
+    describe('check()', () => {
+        it('returns null for valid source', () => {
+            const source = 'fn test() { say("hello"); }';
+            const error = (0, index_1.check)(source);
+            expect(error).toBeNull();
+        });
+        it('returns error for invalid source', () => {
+            const source = 'fn test( { say("hello"); }'; // Missing )
+            const error = (0, index_1.check)(source);
+            expect(error).toBeInstanceOf(Error);
+        });
+        it('returns error for syntax errors', () => {
+            const source = 'fn test() { let x = ; }'; // Missing value
+            const error = (0, index_1.check)(source);
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+});
+//# sourceMappingURL=cli.test.js.map

package/dist/__tests__/codegen.test.d.ts

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

package/dist/__tests__/codegen.test.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcfunction_1 = require("../codegen/mcfunction");
+describe('generateDatapack', () => {
+    it('generates pack.mcmeta', () => {
+        const mod = { namespace: 'test', functions: [], globals: [] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const meta = files.find(f => f.path === 'pack.mcmeta');
+        expect(meta).toBeDefined();
+        expect(JSON.parse(meta.content).pack.pack_format).toBe(26);
+    });
+    it('generates __load.mcfunction with objective setup', () => {
+        const mod = { namespace: 'mypack', functions: [], globals: ['counter'] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const load = files.find(f => f.path.includes('__load.mcfunction'));
+        expect(load?.content).toContain('scoreboard objectives add rs dummy');
+        expect(load?.content).toContain('scoreboard players set $counter rs 0');
+    });
+    it('generates function file for simple add(a, b)', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'add',
+                    params: ['a', 'b'],
+                    locals: ['a', 'b', 'result'],
+                    blocks: [{
+                            label: 'entry',
+                            instrs: [
+                                { op: 'binop', dst: 'result', lhs: { kind: 'var', name: 'a' }, bop: '+', rhs: { kind: 'var', name: 'b' } },
+                            ],
+                            term: { op: 'return', value: { kind: 'var', name: 'result' } },
+                        }],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const fn = files.find(f => f.path.includes('add.mcfunction'));
+        expect(fn).toBeDefined();
+        // Should have param setup
+        expect(fn.content).toContain('scoreboard players operation $a rs = $p0 rs');
+        expect(fn.content).toContain('scoreboard players operation $b rs = $p1 rs');
+        // Should have add operation
+        expect(fn.content).toContain('+=');
+    });
+    it('generates tick tag for tick loop function', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'game_loop',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    isTickLoop: true,
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        // tick.json should point to __tick
+        const tickTag = files.find(f => f.path.includes('tick.json'));
+        expect(tickTag).toBeDefined();
+        expect(JSON.parse(tickTag.content).values).toContain('mypack:__tick');
+        // __tick.mcfunction should call the game_loop function
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('function mypack:game_loop');
+    });
+    it('generates conditional branches with execute if/unless', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'check',
+                    params: [],
+                    locals: ['cond'],
+                    blocks: [
+                        {
+                            label: 'entry',
+                            instrs: [
+                                { op: 'assign', dst: 'cond', src: { kind: 'const', value: 1 } },
+                            ],
+                            term: { op: 'jump_if', cond: 'cond', then: 'then_block', else_: 'else_block' },
+                        },
+                        {
+                            label: 'then_block',
+                            instrs: [{ op: 'raw', cmd: 'say hello' }],
+                            term: { op: 'return' },
+                        },
+                        {
+                            label: 'else_block',
+                            instrs: [{ op: 'raw', cmd: 'say goodbye' }],
+                            term: { op: 'return' },
+                        },
+                    ],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const entry = files.find(f => f.path.endsWith('check.mcfunction'));
+        expect(entry?.content).toContain('execute if score $cond rs matches 1..');
+        expect(entry?.content).toContain('execute if score $cond rs matches ..0');
+    });
+    it('generates advancement json for event decorators', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'on_mine_diamond',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventTrigger: { kind: 'advancement', value: 'story/mine_diamond' },
+                }],
+        };
+        const result = (0, mcfunction_1.generateDatapackWithStats)(mod);
+        const advancement = result.advancements.find(f => f.path === 'data/mypack/advancements/on_advancement_on_mine_diamond.json');
+        expect(advancement).toBeDefined();
+        const json = JSON.parse(advancement.content);
+        expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond');
+        expect(json.rewards.function).toBe('mypack:on_mine_diamond');
+    });
+});
+//# sourceMappingURL=codegen.test.js.map

package/dist/__tests__/diagnostics.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Diagnostics Tests
+ */
+export {};

package/dist/__tests__/diagnostics.test.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Diagnostics Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const diagnostics_1 = require("../diagnostics");
+const compile_1 = require("../compile");
+describe('DiagnosticError', () => {
+    describe('formatError', () => {
+        it('formats source context with a caret pointer', () => {
+            const source = [
+                'fn main() {',
+                '  let x = foo(',
+                '}',
+            ].join('\n');
+            const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { line: 2, col: 11 }, source.split('\n'));
+            expect((0, diagnostics_1.formatError)(error, source)).toBe([
+                'Error at line 2, col 11:',
+                '    let x = foo(',
+                '            ^',
+                'Unknown function: foo',
+            ].join('\n'));
+        });
+        it('includes file path when available', () => {
+            const source = 'let x = foo();';
+            const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { file: 'test.rs', line: 1, col: 9 }, source.split('\n'));
+            expect((0, diagnostics_1.formatError)(error, source)).toContain('Error in test.rs at line 1, col 9:');
+        });
+    });
+    describe('format', () => {
+        it('formats error with source line and pointer', () => {
+            const sourceLines = [
+                'fn main() {',
+                '  let x = 42',
+                '}',
+            ];
+            const error = new diagnostics_1.DiagnosticError('ParseError', "Expected ';' after statement", { line: 2, col: 14 }, sourceLines);
+            const formatted = error.format();
+            expect(formatted).toContain('[ParseError]');
+            expect(formatted).toContain('line 2');
+            expect(formatted).toContain('col 14');
+            expect(formatted).toContain('let x = 42');
+            expect(formatted).toContain('^');
+        });
+        it('formats error with file path', () => {
+            const error = new diagnostics_1.DiagnosticError('LexError', 'Unexpected character', { file: 'test.rs', line: 1, col: 1 }, ['@@@']);
+            const formatted = error.format();
+            expect(formatted).toContain('test.rs:');
+            expect(formatted).toContain('[LexError]');
+        });
+        it('handles missing source lines gracefully', () => {
+            const error = new diagnostics_1.DiagnosticError('ParseError', 'Syntax error', { line: 10, col: 5 });
+            const formatted = error.format();
+            expect(formatted).toContain('[ParseError]');
+            expect(formatted).toContain('line 10');
+        });
+    });
+});
+describe('DiagnosticCollector', () => {
+    it('collects multiple errors', () => {
+        const collector = new diagnostics_1.DiagnosticCollector('line1\nline2\nline3');
+        collector.error('ParseError', 'First error', 1, 1);
+        collector.error('ParseError', 'Second error', 2, 1);
+        expect(collector.hasErrors()).toBe(true);
+        expect(collector.getErrors()).toHaveLength(2);
+    });
+    it('formats all errors', () => {
+        const collector = new diagnostics_1.DiagnosticCollector('let x');
+        collector.error('ParseError', 'Missing semicolon', 1, 6);
+        const formatted = collector.formatAll();
+        expect(formatted).toContain('Missing semicolon');
+        expect(formatted).toContain('let x');
+    });
+});
+describe('parseErrorMessage', () => {
+    it('extracts line and col from error message', () => {
+        const err = (0, diagnostics_1.parseErrorMessage)('ParseError', "Expected ';' at line 5, col 12", ['', '', '', '', 'let x = 42']);
+        expect(err.location.line).toBe(5);
+        expect(err.location.col).toBe(12);
+        expect(err.message).toBe("Expected ';'");
+    });
+    it('defaults to line 1, col 1 if no position in message', () => {
+        const err = (0, diagnostics_1.parseErrorMessage)('LexError', 'Unknown error');
+        expect(err.location.line).toBe(1);
+        expect(err.location.col).toBe(1);
+    });
+});
+describe('compile function', () => {
+    it('returns success for valid code', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = 1; }');
+        expect(result.success).toBe(true);
+        expect(result.files).toBeDefined();
+    });
+    it('returns DiagnosticError for lex errors', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = $ }');
+        expect(result.success).toBe(false);
+        expect(result.error).toBeInstanceOf(diagnostics_1.DiagnosticError);
+        expect(result.error?.kind).toBe('LexError');
+    });
+    it('returns DiagnosticError for parse errors', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = }');
+        expect(result.success).toBe(false);
+        expect(result.error).toBeInstanceOf(diagnostics_1.DiagnosticError);
+        expect(result.error?.kind).toBe('ParseError');
+    });
+    it('returns DiagnosticError for missing semicolon', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = 42 }');
+        expect(result.success).toBe(false);
+        expect(result.error?.kind).toBe('ParseError');
+        expect(result.error?.message).toContain("Expected ';'");
+    });
+    it('includes file path in error', () => {
+        const result = (0, compile_1.compile)('fn main() { }', { filePath: 'test.rs' });
+        // This is valid, but test that filePath is passed through
+        expect(result.success).toBe(true);
+    });
+    it('formats error nicely', () => {
+        const result = (0, compile_1.compile)('fn main() {\n  let x = 42\n}');
+        expect(result.success).toBe(false);
+        const formatted = (0, compile_1.formatCompileError)(result);
+        expect(formatted).toContain('Error at line');
+        expect(formatted).toContain('^');
+        // Error points to } on line 3, which is where semicolon was expected
+        expect(formatted).toContain('}');
+    });
+});
+describe('Lexer DiagnosticError', () => {
+    it('throws DiagnosticError for unexpected character', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = $ }');
+        expect(result.success).toBe(false);
+        expect(result.error?.kind).toBe('LexError');
+        expect(result.error?.message).toContain('Unexpected character');
+    });
+    it('throws DiagnosticError for unterminated string', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = "hello }');
+        expect(result.success).toBe(false);
+        expect(result.error?.kind).toBe('LexError');
+        expect(result.error?.message).toContain('Unterminated string');
+    });
+});
+describe('Parser DiagnosticError', () => {
+    it('includes line and column info', () => {
+        const result = (0, compile_1.compile)('fn main() { return }');
+        expect(result.success).toBe(false);
+        expect(result.error?.location.line).toBeGreaterThan(0);
+        expect(result.error?.location.col).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=diagnostics.test.js.map