Claude Code编译器实战：五天从零造一门编程语言

flowchart TD
    A[编译器开发传统路径] -->|数月手写| B[Lexer → Parser → AST]
    B --> C[Semantic Analysis]
    C --> D[Code Generation]
    D --> E[VM / Native Output]

    F[Claude Code加速路径] -->|1-5天迭代| G[描述语言规范]
    G --> H[逐层生成+测试]
    H --> I[集成调试优化]

    style F fill:#e8f5e9
    style G fill:#e8f5e9
    style H fill:#e8f5e9
    style I fill:#e8f5e9

# 创建项目
mkdir minilang && cd minilang
npm init -y
npm install -D vitest typescript @types/node
npx tsc --init

# 用Claude Code初始化项目结构
claude "帮我设计一个叫MiniLang的编程语言项目结构，包含src/lexer、src/parser、src/ast、src/compiler、src/vm五个模块，以及对应的tests目录"

flowchart LR
    subgraph Frontend["前端 (Frontend)"]
        SRC[源代码] --> LEX[Lexer<br/>词法分析]
        LEX --> |Token流| PAR[Parser<br/>语法分析]
        PAR --> |AST| SEM[Semantic<br/>语义检查]
    end

    subgraph Middle["中间层 (Middle)"]
        SEM --> |带类型AST| COMP[Compiler<br/>字节码编译]
        COMP --> |字节码| OPT[Optimizer<br/>常量折叠等]
    end

    subgraph Backend["后端 (Backend)"]
        OPT --> VM[VM<br/>栈式虚拟机]
        VM --> OUT[执行结果]
    end

    style Frontend fill:#e3f2fd
    style Middle fill:#fff3e0
    style Backend fill:#e8f5e9

minilang/
├── src/
│   ├── lexer/
│   │   ├── tokenizer.ts      # 词法分析器
│   │   └── token.ts           # Token类型定义
│   ├── parser/
│   │   ├── parser.ts          # 递归下降解析器
│   │   └── expression.ts      # 表达式解析（Pratt解析）
│   ├── ast/
│   │   ├── nodes.ts           # AST节点定义
│   │   └── visitor.ts         # 访问者模式接口
│   ├── compiler/
│   │   ├── compiler.ts        # AST→字节码编译器
│   │   └── opcode.ts          # 操作码定义
│   ├── vm/
│   │   ├── vm.ts              # 栈式虚拟机
│   │   ├── frame.ts           # 调用栈帧
│   │   └── object.ts          # 运行时对象
│   └── repl.ts                # 交互式REPL
├── tests/
│   ├── lexer.test.ts
│   ├── parser.test.ts
│   ├── compiler.test.ts
│   └── vm.test.ts
├── package.json
└── tsconfig.json

请设计MiniLang的完整Token类型体系，要求：
1. 支持以下Token类型：Number, String, Identifier, 关键字(let, fn, if, else, while, return, true, false)
2. 运算符：+, -, *, /, %, ==, !=, <, >, <=, >=, &&, ||, !, =
3. 分隔符：(, ), {, }, [, ], ;, ,, :
4. 每个Token包含type, literal(原始值), line, column
5. 用TypeScript enum + class实现
6. 包含完整的单元测试

export enum TokenType {
  // Literals
  Number, String, Identifier,
  // Keywords
  Let, Fn, If, Else, While, Return, True, False,
  // Operators
  Plus, Minus, Star, Slash, Percent,
  Equal, EqualEqual, Bang, BangEqual,
  Less, LessEqual, Greater, GreaterEqual,
  And, Or,
  // Delimiters
  LParen, RParen, LBrace, RBrace,
  LBracket, RBracket, Semicolon, Comma, Colon,
  // Special
  Eof,
}

export class Token {
  constructor(
    public type: TokenType,
    public literal: string,
    public line: number,
    public column: number,
  ) {}
}

// 关键字映射表
const KEYWORDS: Record<string, TokenType> = {
  let:      TokenType.Let,
  fn:       TokenType.Fn,
  if:       TokenType.If,
  else:     TokenType.Else,
  while:    TokenType.While,
  return:   TokenType.Return,
  true:     TokenType.True,
  false:    TokenType.False,
};

export function lookupKeyword(ident: string): TokenType | null {
  return KEYWORDS[ident] ?? null;
}

请实现src/lexer/tokenizer.ts，要求：
1. 逐字符扫描源码，生成Token数组
2. 正确处理多字符运算符（==, !=, <=, >=, &&, ||）
3. 跳过空白和注释（//单行注释）
4. 字符串字面量用双引号，支持转义字符\n, \t, \", \\
5. 数字支持整数和浮点数
6. 错误报告包含行列号
7. 先写测试用例再写实现

import { Token, TokenType, lookupKeyword } from './token';

export class Lexer {
  private position = 0;
  private line = 1;
  private column = 1;
  private tokens: Token[] = [];

  constructor(private source: string) {}

  tokenize(): Token[] {
    while (!this.isAtEnd()) {
      this.skipWhitespace();
      if (this.isAtEnd()) break;
      this.scanToken();
    }
    this.tokens.push(new Token(TokenType.Eof, '', this.line, this.column));
    return this.tokens;
  }

  private scanToken(): void {
    const char = this.advance();

    switch (char) {
      // 单字符Token
      case '(': this.addToken(TokenType.LParen); break;
      case ')': this.addToken(TokenType.RParen); break;
      case '{': this.addToken(TokenType.LBrace); break;
      case '}': this.addToken(TokenType.RBrace); break;
      case '[': this.addToken(TokenType.LBracket); break;
      case ']': this.addToken(TokenType.RBracket); break;
      case ';': this.addToken(TokenType.Semicolon); break;
      case ',': this.addToken(TokenType.Comma); break;
      case ':': this.addToken(TokenType.Colon); break;
      case '+': this.addToken(TokenType.Plus); break;
      case '-': this.addToken(TokenType.Minus); break;
      case '*': this.addToken(TokenType.Star); break;
      case '/':
        if (this.match('/')) {
          // 单行注释
          while (this.peek() !== '\n' && !this.isAtEnd()) this.advance();
        } else {
          this.addToken(TokenType.Slash);
        }
        break;
      case '%': this.addToken(TokenType.Percent); break;
      // 双字符Token
      case '=':
        this.addToken(this.match('=') ? TokenType.EqualEqual : TokenType.Equal);
        break;
      case '!':
        this.addToken(this.match('=') ? TokenType.BangEqual : TokenType.Bang);
        break;
      case '<':
        this.addToken(this.match('=') ? TokenType.LessEqual : TokenType.Less);
        break;
      case '>':
        this.addToken(this.match('=') ? TokenType.GreaterEqual : TokenType.Greater);
        break;
      case '&':
        if (this.match('&')) this.addToken(TokenType.And);
        else throw this.error('&', '&&');
        break;
      case '|':
        if (this.match('|')) this.addToken(TokenType.Or);
        else throw this.error('|', '||');
        break;
      // 字符串
      case '"': this.readString(); break;
      default:
        if (this.isDigit(char)) {
          this.readNumber();
        } else if (this.isAlpha(char)) {
          this.readIdentifier();
        } else {
          throw new Error(
            `Unexpected character '${char}' at ${this.line}:${this.column}`
          );
        }
    }
  }

  private readNumber(): void {
    const start = this.position - 1;
    while (this.isDigit(this.peek())) this.advance();
    // 浮点数
    if (this.peek() === '.' && this.isDigit(this.peekNext())) {
      this.advance(); // 消费 '.'
      while (this.isDigit(this.peek())) this.advance();
    }
    const literal = this.source.slice(start, this.position);
    this.tokens.push(new Token(TokenType.Number, literal, this.line, this.column));
  }

  private readString(): void {
    const start = this.position;
    while (this.peek() !== '"' && !this.isAtEnd()) {
      if (this.peek() === '\n') this.line++;
      if (this.peek() === '\\') this.advance(); // 跳过转义
      this.advance();
    }
    if (this.isAtEnd()) throw new Error('Unterminated string');
    this.advance(); // 消费结尾 "
    const literal = this.source.slice(start, this.position - 1);
    this.tokens.push(
      new Token(TokenType.String, literal.replace(/\\n/g, '\n')
        .replace(/\\t/g, '\t').replace(/\\"/g, '"').replace(/\\\\/g, '\\'),
        this.line, this.column)
    );
  }

  private readIdentifier(): void {
    const start = this.position - 1;
    while (this.isAlphaNumeric(this.peek())) this.advance();
    const literal = this.source.slice(start, this.position);
    const type = lookupKeyword(literal) ?? TokenType.Identifier;
    this.tokens.push(new Token(type, literal, this.line, this.column));
  }

  // 辅助方法省略...
  private advance(): string { this.column++; return this.source[this.position++]; }
  private peek(): string { return this.source[this.position] ?? '\0'; }
  private peekNext(): string { return this.source[this.position + 1] ?? '\0'; }
  private match(expected: string): boolean {
    if (this.source[this.position] !== expected) return false;
    this.position++; this.column++; return true;
  }
  private isAtEnd(): boolean { return this.position >= this.source.length; }
  private addToken(type: TokenType): void {
    this.tokens.push(new Token(type, this.source[this.position - 1], this.line, this.column));
  }
  private isDigit(c: string): boolean { return c >= '0' && c <= '9'; }
  private isAlpha(c: string): boolean { return /[a-zA-Z_]/.test(c); }
  private isAlphaNumeric(c: string): boolean { return this.isAlpha(c) || this.isDigit(c); }
  private skipWhitespace(): void {
    while (/\s/.test(this.peek())) {
      if (this.peek() === '\n') { this.line++; this.column = 0; }
      this.advance();
    }
  }
  private error(char: string, expected: string): Error {
    return new Error(`Expected '${expected}' at ${this.line}:${this.column}`);
  }
}

// tests/lexer.test.ts
import { describe, it, expect } from 'vitest';
import { Lexer } from '../src/lexer/tokenizer';
import { TokenType } from '../src/lexer/token';

describe('Lexer', () => {
  it('tokenizes number literals', () => {
    const tokens = new Lexer('42 3.14').tokenize();
    expect(tokens[0].type).toBe(TokenType.Number);
    expect(tokens[0].literal).toBe('42');
    expect(tokens[1].type).toBe(TokenType.Number);
    expect(tokens[1].literal).toBe('3.14');
  });

  it('tokenizes string literals with escapes', () => {
    const tokens = new Lexer('"hello\\nworld"').tokenize();
    expect(tokens[0].type).toBe(TokenType.String);
    expect(tokens[0].literal).toBe('hello\nworld');
  });

  it('recognizes all keywords', () => {
    const src = 'let fn if else while return true false';
    const tokens = new Lexer(src).tokenize();
    const types = tokens.map(t => t.type);
    expect(types).toContain(TokenType.Let);
    expect(types).toContain(TokenType.Fn);
    expect(types).toContain(TokenType.If);
    expect(types).toContain(TokenType.Else);
    expect(types).toContain(TokenType.While);
    expect(types).toContain(TokenType.Return);
    expect(types).toContain(TokenType.True);
    expect(types).toContain(TokenType.False);
  });

  it('handles two-character operators', () => {
    const tokens = new Lexer('== != <= >= && ||').tokenize();
    expect(tokens[0].type).toBe(TokenType.EqualEqual);
    expect(tokens[1].type).toBe(TokenType.BangEqual);
    expect(tokens[2].type).toBe(TokenType.LessEqual);
    expect(tokens[3].type).toBe(TokenType.GreaterEqual);
    expect(tokens[4].type).toBe(TokenType.And);
    expect(tokens[5].type).toBe(TokenType.Or);
  });

  it('skips comments', () => {
    const tokens = new Lexer('let x = 1 // comment\nlet y = 2').tokenize();
    const lets = tokens.filter(t => t.type === TokenType.Let);
    expect(lets).toHaveLength(2);
  });

  it('reports errors with position', () => {
    expect(() => new Lexer('let x = @').tokenize()).toThrow(/Unexpected character/);
  });
});

请为MiniLang设计完整的AST节点体系：
1. 使用TypeScript discriminated union，每个节点有kind字段用于类型判断
2. 表达式节点：NumberLiteral, StringLiteral, BooleanLiteral, Identifier, BinaryExpr, UnaryExpr, CallExpr, AssignExpr
3. 语句节点：LetStmt, ExpressionStmt, IfStmt, WhileStmt, FnDeclStmt, ReturnStmt, BlockStmt
4. 所有节点共享一个基础接口 { kind: string; line: number; column: number; }
5. 使用访问者模式（Visitor Pattern）定义遍历接口

// ============ 基础接口 ============
export interface ASTNode {
  kind: string;
  line: number;
  column: number;
}

// ============ 表达式节点 ============
export interface NumberLiteral extends ASTNode {
  kind: 'NumberLiteral';
  value: number;
}

export interface StringLiteral extends ASTNode {
  kind: 'StringLiteral';
  value: string;
}

export interface BooleanLiteral extends ASTNode {
  kind: 'BooleanLiteral';
  value: boolean;
}

export interface Identifier extends ASTNode {
  kind: 'Identifier';
  name: string;
}

export interface BinaryExpr extends ASTNode {
  kind: 'BinaryExpr';
  operator: string;
  left: Expression;
  right: Expression;
}

export interface UnaryExpr extends ASTNode {
  kind: 'UnaryExpr';
  operator: string;
  operand: Expression;
}

export interface CallExpr extends ASTNode {
  kind: 'CallExpr';
  callee: Expression;
  args: Expression[];
}

export interface AssignExpr extends ASTNode {
  kind: 'AssignExpr';
  target: Identifier;
  value: Expression;
}

export type Expression =
  | NumberLiteral | StringLiteral | BooleanLiteral
  | Identifier | BinaryExpr | UnaryExpr
  | CallExpr | AssignExpr;

// ============ 语句节点 ============
export interface LetStmt extends ASTNode {
  kind: 'LetStmt';
  name: string;
  initializer: Expression;
}

export interface ExpressionStmt extends ASTNode {
  kind: 'ExpressionStmt';
  expression: Expression;
}

export interface IfStmt extends ASTNode {
  kind: 'IfStmt';
  condition: Expression;
  thenBranch: BlockStmt;
  elseBranch?: BlockStmt | IfStmt;
}

export interface WhileStmt extends ASTNode {
  kind: 'WhileStmt';
  condition: Expression;
  body: BlockStmt;
}

export interface FnDeclStmt extends ASTNode {
  kind: 'FnDeclStmt';
  name: string;
  params: string[];
  body: BlockStmt;
}

export interface ReturnStmt extends ASTNode {
  kind: 'ReturnStmt';
  value?: Expression;
}

export interface BlockStmt extends ASTNode {
  kind: 'BlockStmt';
  statements: Statement[];
}

export type Statement =
  | LetStmt | ExpressionStmt | IfStmt
  | WhileStmt | FnDeclStmt | ReturnStmt | BlockStmt;

export type Program = BlockStmt;

// src/ast/visitor.ts
export interface ASTVisitor<T> {
  visitNumberLiteral(node: NumberLiteral): T;
  visitStringLiteral(node: StringLiteral): T;
  visitBooleanLiteral(node: BooleanLiteral): T;
  visitIdentifier(node: Identifier): T;
  visitBinaryExpr(node: BinaryExpr): T;
  visitUnaryExpr(node: UnaryExpr): T;
  visitCallExpr(node: CallExpr): T;
  visitAssignExpr(node: AssignExpr): T;
  visitLetStmt(node: LetStmt): T;
  visitExpressionStmt(node: ExpressionStmt): T;
  visitIfStmt(node: IfStmt): T;
  visitWhileStmt(node: WhileStmt): T;
  visitFnDeclStmt(node: FnDeclStmt): T;
  visitReturnStmt(node: ReturnStmt): T;
  visitBlockStmt(node: BlockStmt): T;
}

export function accept<T>(node: ASTNode, visitor: ASTVisitor<T>): T {
  switch (node.kind) {
    case 'NumberLiteral':  return visitor.visitNumberLiteral(node as NumberLiteral);
    case 'StringLiteral':  return visitor.visitStringLiteral(node as StringLiteral);
    case 'BooleanLiteral': return visitor.visitBooleanLiteral(node as BooleanLiteral);
    case 'Identifier':     return visitor.visitIdentifier(node as Identifier);
    case 'BinaryExpr':     return visitor.visitBinaryExpr(node as BinaryExpr);
    case 'UnaryExpr':      return visitor.visitUnaryExpr(node as UnaryExpr);
    case 'CallExpr':       return visitor.visitCallExpr(node as CallExpr);
    case 'AssignExpr':     return visitor.visitAssignExpr(node as AssignExpr);
    case 'LetStmt':        return visitor.visitLetStmt(node as LetStmt);
    case 'ExpressionStmt': return visitor.visitExpressionStmt(node as ExpressionStmt);
    case 'IfStmt':         return visitor.visitIfStmt(node as IfStmt);
    case 'WhileStmt':      return visitor.visitWhileStmt(node as WhileStmt);
    case 'FnDeclStmt':     return visitor.visitFnDeclStmt(node as FnDeclStmt);
    case 'ReturnStmt':     return visitor.visitReturnStmt(node as ReturnStmt);
    case 'BlockStmt':      return visitor.visitBlockStmt(node as BlockStmt);
    default: throw new Error(`Unknown node kind: ${node.kind}`);
  }
}

请实现src/parser/expression.ts，使用Pratt解析器算法：
1. 定义前缀解析函数（prefix parser）：NumberLiteral, StringLiteral, BooleanLiteral, Identifier, 分组表达式, 一元运算符
2. 定义中缀解析函数（infix parser）：二元运算符（按优先级表）, 函数调用
3. 暴露parseExpression(minPrec: number)函数
4. 包含完善的错误恢复（panic mode synchronization）

请实现src/parser/parser.ts，使用递归下降：
1. parseProgram() → parseStatement() 分发
2. 每种语句类型对应一个parse函数：parseLet, parseFn, parseIf, parseWhile, parseReturn, parseBlock
3. 语句之间用分号分隔
4. 表达式语句由expression.ts的parseExpression处理

import { Token, TokenType } from '../lexer/token';
import type { Expression } from '../ast/nodes';

type PrefixParser = () => Expression;
type InfixParser = (left: Expression) => Expression;

interface ParseRule {
  prefix?: PrefixParser;
  infix?: InfixParser;
  precedence: number;
}

const PREC = {
  None: 0, Or: 1, And: 2, Equality: 3,
  Comparison: 4, Term: 5, Factor: 6, Unary: 7, Call: 8,
};

export class ExpressionParser {
  private current = 0;

  constructor(private tokens: Token[]) {}

  parseExpression(minPrec: number = PREC.None): Expression {
    const prefixRule = this.getRule(this.peek().type).prefix;
    if (!prefixRule) throw this.error(this.peek(), 'Expected expression');

    let left = prefixRule.call(this);

    while (minPrec < this.getRule(this.peek().type).precedence) {
      const infixRule = this.getRule(this.peek().type).infix;
      if (!infixRule) break;
      this.advance();
      left = infixRule.call(this, left);
    }
    return left;
  }

  // 前缀解析：字面量、标识符、一元运算符、分组
  private numberLiteral(): Expression {
    const token = this.previous();
    return { kind: 'NumberLiteral', value: parseFloat(token.literal), line: token.line, column: token.column };
  }

  private stringLiteral(): Expression {
    const token = this.previous();
    return { kind: 'StringLiteral', value: token.literal, line: token.line, column: token.column };
  }

  private booleanLiteral(value: boolean): Expression {
    const token = this.previous();
    return { kind: 'BooleanLiteral', value, line: token.line, column: token.column };
  }

  private identifier(): Expression {
    const token = this.previous();
    return { kind: 'Identifier', name: token.literal, line: token.line, column: token.column };
  }

  private grouping(): Expression {
    const expr = this.parseExpression(PREC.None);
    this.consume(TokenType.RParen, "Expected ')' after expression");
    return expr;
  }

  private unary(): Expression {
    const op = this.previous();
    const operand = this.parseExpression(PREC.Unary);
    return { kind: 'UnaryExpr', operator: op.literal, operand, line: op.line, column: op.column };
  }

  // 中缀解析：二元运算
  private binary(left: Expression): Expression {
    const op = this.previous();
    const rule = this.getRule(op.type);
    const right = this.parseExpression(rule.precedence);
    return { kind: 'BinaryExpr', operator: op.literal, left, right, line: op.line, column: op.column };
  }

  // 中缀解析：函数调用
  private call(callee: Expression): Expression {
    const args: Expression[] = [];
    if (!this.check(TokenType.RParen)) {
      do { args.push(this.parseExpression(PREC.None)); }
      while (this.match(TokenType.Comma));
    }
    const paren = this.consume(TokenType.RParen, "Expected ')' after arguments");
    return { kind: 'CallExpr', callee, args, line: paren.line, column: paren.column };
  }

  // 解析规则表
  private getRule(type: TokenType): ParseRule {
    const rules: Partial<Record<TokenType, ParseRule>> = {
      [TokenType.Number]:  { prefix: this.numberLiteral.bind(this), precedence: PREC.None },
      [TokenType.String]:  { prefix: this.readString.bind(this), precedence: PREC.None },
      [TokenType.True]:    { prefix: () => this.booleanLiteral(true), precedence: PREC.None },
      [TokenType.False]:   { prefix: () => this.booleanLiteral(false), precedence: PREC.None },
      [TokenType.Identifier]: { prefix: this.identifier.bind(this), precedence: PREC.None },
      [TokenType.LParen]:  { prefix: this.grouping.bind(this), infix: this.call.bind(this), precedence: PREC.Call },
      [TokenType.Bang]:    { prefix: this.unary.bind(this), precedence: PREC.None },
      [TokenType.Minus]:   { prefix: this.unary.bind(this), infix: this.binary.bind(this), precedence: PREC.Term },
      [TokenType.Plus]:    { infix: this.binary.bind(this), precedence: PREC.Term },
      [TokenType.Star]:    { infix: this.binary.bind(this), precedence: PREC.Factor },
      [TokenType.Slash]:   { infix: this.binary.bind(this), precedence: PREC.Factor },
      [TokenType.Percent]: { infix: this.binary.bind(this), precedence: PREC.Factor },
      [TokenType.EqualEqual]: { infix: this.binary.bind(this), precedence: PREC.Equality },
      [TokenType.BangEqual]:  { infix: this.binary.bind(this), precedence: PREC.Equality },
      [TokenType.Less]:       { infix: this.binary.bind(this), precedence: PREC.Comparison },
      [TokenType.LessEqual]:  { infix: this.binary.bind(this), precedence: PREC.Comparison },
      [TokenType.Greater]:    { infix: this.binary.bind(this), precedence: PREC.Comparison },
      [TokenType.GreaterEqual]: { infix: this.binary.bind(this), precedence: PREC.Comparison },
      [TokenType.And]:        { infix: this.binary.bind(this), precedence: PREC.And },
      [TokenType.Or]:         { infix: this.binary.bind(this), precedence: PREC.Or },
    };
    return rules[type] ?? { precedence: PREC.None };
  }

  // Token辅助方法
  private advance(): Token { return this.tokens[this.current++]; }
  private previous(): Token { return this.tokens[this.current - 1]; }
  private peek(): Token { return this.tokens[this.current]; }
  private check(type: TokenType): boolean { return this.peek().type === type; }
  private match(type: TokenType): boolean {
    if (this.check(type)) { this.advance(); return true; }
    return false;
  }
  private consume(type: TokenType, msg: string): Token {
    if (this.check(type)) return this.advance();
    throw this.error(this.peek(), msg);
  }
  private error(token: Token, msg: string): Error {
    return new Error(`Parse error at ${token.line}:${token.column} — ${msg}`);
  }
}

// src/compiler/opcode.ts
export enum OpCode {
  // 常量
  Constant,     // 加载常量到栈顶
  // 算术运算
  Add, Subtract, Multiply, Divide, Modulo,
  // 比较
  Equal, NotEqual, Less, LessEqual, Greater, GreaterEqual,
  // 逻辑
  Not, And, Or,
  // 变量
  GetLocal, SetLocal, GetGlobal, SetGlobal,
  // 控制流
  Jump,         // 无条件跳转
  JumpIfFalse,  // 条件假跳转
  JumpIfTrue,   // 条件真跳转
  Loop,         // 回跳（用于循环）
  // 函数
  Call,         // 调用函数
  Return,       // 返回
  // 栈操作
  Pop,          // 弹出栈顶
  Print,        // 打印栈顶
}

export class Bytecode {
  instructions: number[] = [];     // 操作码 + 操作数
  constants: any[] = [];           // 常量池
  lines: number[] = [];            // 行号映射（调试用）

  emitByte(byte: number, line: number): void {
    this.instructions.push(byte);
    this.lines.push(line);
  }

  emitBytes(...bytes: number[]): void {
    const line = this.lines[this.lines.length - 1] ?? 0;
    for (const b of bytes) this.instructions.push(b);
    for (const _ of bytes) this.lines.push(line);
  }

  emitConstant(value: any, line: number): void {
    const index = this.addConstant(value);
    this.emitByte(OpCode.Constant, line);
    this.emitBytes(index);
  }

  addConstant(value: any): number {
    this.constants.push(value);
    return this.constants.length - 1;
  }
}

请实现src/compiler/compiler.ts，使用ASTVisitor模式遍历AST并生成字节码：
1. 每种表达式/语句类型对应一个emit方法
2. BinaryExpr：left → right → operator（中缀转后缀）
3. IfStmt：condition → JumpIfFalse → then → Jump → else
4. WhileStmt：Loop标记 → condition → JumpIfFalse → body → Loop回跳
5. FnDeclStmt：编译为独立的Bytecode对象，存入常量池
6. CallStmt：依次编译参数，emit Call + 参数数量
7. 局部变量使用栈槽（stack slot），全局变量使用全局表

import { ASTVisitor, accept } from '../ast/visitor';
import { OpCode, Bytecode } from './opcode';
import type * as AST from '../ast/nodes';

class CompilerScope {
  locals: string[] = [];
  parent: CompilerScope | null = null;

  resolveLocal(name: string): number | null {
    const idx = this.locals.indexOf(name);
    if (idx >= 0) return idx;
    return null;
  }

  defineLocal(name: string): number {
    this.locals.push(name);
    return this.locals.length - 1;
  }
}

export class Compiler implements ASTVisitor<void> {
  private bytecode = new Bytecode();
  private scope = new CompilerScope();
  private globalNames: string[] = [];

  compile(program: AST.Program): Bytecode {
    this.visitBlockStmt(program);
    this.bytecode.emitByte(OpCode.Return, 0);
    return this.bytecode;
  }

  // ============ 表达式编译 ============

  visitNumberLiteral(node: AST.NumberLiteral): void {
    this.bytecode.emitConstant(node.value, node.line);
  }

  visitStringLiteral(node: AST.StringLiteral): void {
    this.bytecode.emitConstant(node.value, node.line);
  }

  visitBooleanLiteral(node: AST.BooleanLiteral): void {
    // 优化：true/false用常量池中预定义的布尔值
    this.bytecode.emitConstant(node.value, node.line);
  }

  visitIdentifier(node: AST.Identifier): void {
    const local = this.scope.resolveLocal(node.name);
    if (local !== null) {
      this.bytecode.emitBytes(OpCode.GetLocal, local);
    } else {
      const global = this.globalNames.indexOf(node.name);
      if (global < 0) throw new Error(`Undefined variable: ${node.name}`);
      this.bytecode.emitBytes(OpCode.GetGlobal, global);
    }
  }

  visitBinaryExpr(node: AST.BinaryExpr): void {
    accept(node.left, this);
    accept(node.right, this);
    const opMap: Record<string, OpCode> = {
      '+': OpCode.Add, '-': OpCode.Subtract,
      '*': OpCode.Multiply, '/': OpCode.Divide, '%': OpCode.Modulo,
      '==': OpCode.Equal, '!=': OpCode.NotEqual,
      '<': OpCode.Less, '<=': OpCode.LessEqual,
      '>': OpCode.Greater, '>=': OpCode.GreaterEqual,
      '&&': OpCode.And, '||': OpCode.Or,
    };
    const opcode = opMap[node.operator];
    if (opcode === undefined) throw new Error(`Unknown operator: ${node.operator}`);
    this.bytecode.emitBytes(opcode);
  }

  visitUnaryExpr(node: AST.UnaryExpr): void {
    accept(node.operand, this);
    if (node.operator === '!') this.bytecode.emitBytes(OpCode.Not);
    else if (node.operator === '-') this.bytecode.emitBytes(OpCode.Subtract);
  }

  visitCallExpr(node: AST.CallExpr): void {
    accept(node.callee, this);
    for (const arg of node.args) accept(arg, this);
    this.bytecode.emitBytes(OpCode.Call, node.args.length);
  }

  visitAssignExpr(node: AST.AssignExpr): void {
    accept(node.value, this);
    const local = this.scope.resolveLocal(node.target.name);
    if (local !== null) {
      this.bytecode.emitBytes(OpCode.SetLocal, local);
    } else {
      const global = this.globalNames.indexOf(node.target.name);
      this.bytecode.emitBytes(OpCode.SetGlobal, global);
    }
  }

  // ============ 语句编译 ============

  visitLetStmt(node: AST.LetStmt): void {
    accept(node.initializer, this);
    if (this.scope.parent === null) {
      // 全局作用域
      this.globalNames.push(node.name);
    } else {
      this.scope.defineLocal(node.name);
    }
  }

  visitIfStmt(node: AST.IfStmt): void {
    accept(node.condition, this);
    const thenJump = this.emitJump(OpCode.JumpIfFalse);
    accept(node.thenBranch, this);
    const elseJump = this.emitJump(OpCode.Jump);
    this.patchJump(thenJump);
    if (node.elseBranch) accept(node.elseBranch, this);
    this.patchJump(elseJump);
  }

  visitWhileStmt(node: AST.WhileStmt): void {
    const loopStart = this.bytecode.instructions.length;
    accept(node.condition, this);
    const exitJump = this.emitJump(OpCode.JumpIfFalse);
    accept(node.body, this);
    this.emitLoop(loopStart);
    this.patchJump(exitJump);
  }

  visitFnDeclStmt(node: AST.FnDeclStmt): void {
    // 保存当前作用域，创建新作用域
    const prevScope = this.scope;
    this.scope = new CompilerScope();
    this.scope.parent = prevScope;
    // 参数作为局部变量
    for (const param of node.params) this.scope.defineLocal(param);
    // 编译函数体
    const fnBytecode = new Bytecode();
    const prevBytecode = this.bytecode;
    this.bytecode = fnBytecode;
    this.visitBlockStmt(node.body);
    this.bytecode.emitByte(OpCode.Return, 0);
    this.bytecode = prevBytecode;
    // 恢复作用域
    this.scope = prevScope;
    // 函数对象存入常量池
    this.bytecode.emitConstant({ name: node.name, params: node.params, bytecode: fnBytecode }, 0);
    if (prevScope.parent === null) {
      this.globalNames.push(node.name);
    }
  }

  visitReturnStmt(node: AST.ReturnStmt): void {
    if (node.value) accept(node.value, this);
    this.bytecode.emitBytes(OpCode.Return);
  }

  visitBlockStmt(node: AST.BlockStmt): void {
    for (const stmt of node.statements) accept(stmt, this);
  }

  visitExpressionStmt(node: AST.ExpressionStmt): void {
    accept(node.expression, this);
    this.bytecode.emitBytes(OpCode.Pop); // 表达式语句丢弃结果
  }

  // ============ 跳转辅助 ============

  private emitJump(opcode: OpCode): number {
    this.bytecode.emitBytes(opcode);
    this.bytecode.emitBytes(0xFF); // 占位
    return this.bytecode.instructions.length - 1;
  }

  private patchJump(offset: number): void {
    this.bytecode.instructions[offset] = this.bytecode.instructions.length;
  }

  private emitLoop(loopStart: number): void {
    this.bytecode.emitBytes(OpCode.Loop);
    this.bytecode.emitBytes(loopStart);
  }
}

flowchart TD
    subgraph "if-else 编译"
        IF_COND["条件表达式"] --> |"emit条件字节码"| JUMP_FALSE["JumpIfFalse ?"]
        JUMP_FALSE --> THEN["then分支字节码"]
        THEN --> JUMP_END["Jump ?"]
        JUMP_FALSE --> |"patch跳转地址"| ELSE["else分支字节码"]
        ELSE --> |"patch跳转地址"| END["后续代码"]
        JUMP_END --> |"patch跳转地址"| END
    end

    subgraph "while 编译"
        LOOP_START["LOOP标记位置"] --> WHILE_COND["条件表达式"]
        WHILE_COND --> |"emit条件字节码"| EXIT_JUMP["JumpIfFalse ?"]
        EXIT_JUMP --> BODY["循环体字节码"]
        BODY --> |"emit Loop 回跳"| LOOP_START
        EXIT_JUMP --> |"patch跳转地址"| AFTER["循环后代码"]
    end

flowchart LR
    subgraph VM["栈式虚拟机"]
        STACK["操作栈<br/>(值栈)"]
        CALL_STACK["调用栈<br/>(栈帧链)"]
        GLOBALS["全局变量表"]
        CONSTANTS["常量池"]
    end

    BYTECODE["字节码流"] --> |"fetch-decode-execute"| VM
    VM --> RESULT["执行结果"]

    CALL_STACK --> |"每帧包含"| FRAME["返回地址<br/>局部变量数组<br/>栈基指针"]

import { OpCode, Bytecode } from '../compiler/opcode';

interface CallFrame {
  bytecode: Bytecode;
  ip: number;           // 指令指针
  basePointer: number;  // 栈基指针（局部变量起始位置）
  name: string;
}

export class VM {
  private stack: any[] = [];
  private frames: CallFrame[] = [];
  private globals: Map<string, any> = new Map();

  run(bytecode: Bytecode): any {
    const frame: CallFrame = {
      bytecode,
      ip: 0,
      basePointer: 0,
      name: '<main>',
    };
    this.frames.push(frame);

    while (this.frames.length > 0) {
      const current = this.frames[this.frames.length - 1];
      const instruction = this.readByte(current);

      switch (instruction) {
        case OpCode.Constant: {
          const index = this.readByte(current);
          this.push(current.bytecode.constants[index]);
          break;
        }
        // 算术运算
        case OpCode.Add: {
          const b = this.pop(), a = this.pop();
          this.push(a + b);
          break;
        }
        case OpCode.Subtract: { const b = this.pop(), a = this.pop(); this.push(a - b); break; }
        case OpCode.Multiply: { const b = this.pop(), a = this.pop(); this.push(a * b); break; }
        case OpCode.Divide:   { const b = this.pop(), a = this.pop(); this.push(a / b); break; }
        case OpCode.Modulo:   { const b = this.pop(), a = this.pop(); this.push(a % b); break; }

        // 比较运算
        case OpCode.Equal:        { const b = this.pop(), a = this.pop(); this.push(a === b); break; }
        case OpCode.NotEqual:     { const b = this.pop(), a = this.pop(); this.push(a !== b); break; }
        case OpCode.Less:         { const b = this.pop(), a = this.pop(); this.push(a < b); break; }
        case OpCode.LessEqual:    { const b = this.pop(), a = this.pop(); this.push(a <= b); break; }
        case OpCode.Greater:      { const b = this.pop(), a = this.pop(); this.push(a > b); break; }
        case OpCode.GreaterEqual: { const b = this.pop(), a = this.pop(); this.push(a >= b); break; }

        // 逻辑运算
        case OpCode.Not: { this.push(!this.pop()); break; }
        case OpCode.And: { const b = this.pop(), a = this.pop(); this.push(a && b); break; }
        case OpCode.Or:  { const b = this.pop(), a = this.pop(); this.push(a || b); break; }

        // 变量
        case OpCode.GetLocal: {
          const slot = this.readByte(current);
          this.push(this.stack[current.basePointer + slot]);
          break;
        }
        case OpCode.SetLocal: {
          const slot = this.readByte(current);
          this.stack[current.basePointer + slot] = this.peek();
          break;
        }
        case OpCode.GetGlobal: {
          const name = current.bytecode.constants[this.readByte(current)];
          if (!this.globals.has(name)) throw new Error(`Undefined variable: ${name}`);
          this.push(this.globals.get(name));
          break;
        }
        case OpCode.SetGlobal: {
          const name = current.bytecode.constants[this.readByte(current)];
          this.globals.set(name, this.peek());
          break;
        }

        // 控制流
        case OpCode.Jump: {
          const offset = this.readByte(current);
          current.ip = offset;
          break;
        }
        case OpCode.JumpIfFalse: {
          const offset = this.readByte(current);
          if (!this.pop()) current.ip = offset;
          break;
        }
        case OpCode.Loop: {
          const offset = this.readByte(current);
          current.ip = offset;
          break;
        }

        // 函数调用
        case OpCode.Call: {
          const argCount = this.readByte(current);
          const callee = this.stack[this.stack.length - argCount - 1];
          if (typeof callee === 'function') {
            // 内置函数
            const args = this.stack.splice(this.stack.length - argCount, argCount);
            this.pop(); // 弹出callee
            this.push(callee(...args));
          } else if (callee?.bytecode) {
            // 用户定义函数
            const frame: CallFrame = {
              bytecode: callee.bytecode,
              ip: 0,
              basePointer: this.stack.length - argCount,
              name: callee.name,
            };
            this.frames.push(frame);
          }
          break;
        }
        case OpCode.Return: {
          const result = this.pop();
          this.frames.pop();
          if (this.frames.length > 0) {
            this.push(result);
          } else {
            return result;
          }
          break;
        }

        case OpCode.Pop: { this.pop(); break; }
        case OpCode.Print: { console.log(this.pop()); break; }

        default:
          throw new Error(`Unknown opcode: ${instruction}`);
      }
    }
    return this.pop();
  }

  private readByte(frame: CallFrame): number {
    return frame.bytecode.instructions[frame.ip++];
  }
  private push(value: any): void { this.stack.push(value); }
  private pop(): any { return this.stack.pop(); }
  private peek(): any { return this.stack[this.stack.length - 1]; }
}