feat: IDE支持 — workspace拆分、LSP服务器、VS Code扩展

**Workspace 拆分** - aster-core: 纯库，zero-dependency，包含 lexer/parser/ast/interpreter/error/analysis - aster: REPL 二进制，薄封装 aster-core - aster-lsp: LSP 语言服务器 **VS Code 扩展 (vscode-ext/)** - TextMate 语法高亮 (.ast 文件) - 语言配置 (注释切换、括号配对、自动缩进) - LSP 客户端 (extension.js) **LSP 服务端功能** - Diagnostics: 实时显示 lex/parse 错误红色波浪线 - Completion: 关键字 + 内置函数 + 用户定义符号补全 - Hover: 悬停显示变量/函数信息 - Signature Help: 函数参数提示 - Goto Definition: Ctrl+Click 跳转到声明处 - Find References: 查找所有引用位置 - Rename: F2 重命名符号 **新增 analysis 模块** - collect_symbols: AST 遍历收集符号 - find_declaration/find_all_references: Token 扫描定位声明和引用
2026-06-25 00:28:13 +08:00
parent 99c9e9c9bd
commit bdffe9e3c5
65 changed files with 1709 additions and 47 deletions
@@ -0,0 +1,630 @@
+use crate::ast::*;
+use crate::lexer::{Token, TokenKind};
+use crate::error::RuntimeError;
+
+pub struct Parser {
+    tokens: Vec<Token>,
+    current: usize,
+}
+
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Self {
+        Self { tokens, current: 0 }
+    }
+
+    pub fn parse(&mut self) -> (Vec<Stmt>, Vec<RuntimeError>) {
+        let mut statements = Vec::new();
+        let mut errors = Vec::new();
+
+        while !self.is_at_end() {
+            match self.declaration() {
+                Ok(stmt) => statements.push(stmt),
+                Err(err) => {
+                    errors.push(err);
+                    self.synchronize();
+                }
+            }
+        }
+
+        (statements, errors)
+    }
+
+    fn declaration(&mut self) -> Result<Stmt, RuntimeError> {
+        if self.match_kind(&[TokenKind::Let]) {
+            self.let_declaration(true)
+        } else if self.match_kind(&[TokenKind::Const]) {
+            self.let_declaration(false)
+        } else if self.match_kind(&[TokenKind::Fn]) {
+            self.fn_declaration()
+        } else {
+            self.statement()
+        }
+    }
+
+    fn statement(&mut self) -> Result<Stmt, RuntimeError> {
+        if self.match_kind(&[TokenKind::If]) {
+            self.if_statement()
+        } else if self.match_kind(&[TokenKind::While]) {
+            self.while_statement()
+        } else if self.match_kind(&[TokenKind::For]) {
+            self.for_statement()
+        } else if self.match_kind(&[TokenKind::Break]) {
+            self.break_statement()
+        } else if self.match_kind(&[TokenKind::Continue]) {
+            self.continue_statement()
+        } else if self.match_kind(&[TokenKind::Return]) {
+            self.return_statement()
+        } else if self.match_kind(&[TokenKind::LeftBrace]) {
+            Ok(Stmt::Block(self.block()?))
+        } else {
+            self.expression_statement()
+        }
+    }
+
+    fn let_declaration(&mut self, mutable: bool) -> Result<Stmt, RuntimeError> {
+        let name = self.consume_ident("Expected variable name.")?;
+        self.consume(TokenKind::Equal, "Expected '=' after variable name.")?;
+        let initializer = self.expression()?;
+        self.match_kind(&[TokenKind::Semicolon]); // 分号可选
+
+        Ok(Stmt::Let { name, initializer, mutable })
+    }
+
+    fn fn_declaration(&mut self) -> Result<Stmt, RuntimeError> {
+        let name = self.consume_ident("Expected function name.")?;
+        self.consume(TokenKind::LeftParen, "Expected '(' after function name.")?;
+
+        let mut params = Vec::new();
+        if !self.check(&TokenKind::RightParen) {
+            loop {
+                params.push(self.consume_ident("Expected parameter name.")?);
+                if !self.match_kind(&[TokenKind::Comma]) {
+                    break;
+                }
+            }
+        }
+
+        self.consume(TokenKind::RightParen, "Expected ')' after parameters.")?;
+        self.consume(TokenKind::LeftBrace, "Expected '{' before function body.")?;
+        let body = self.block()?;
+
+        Ok(Stmt::Function { name, params, body })
+    }
+
+    fn lambda_expr(&mut self) -> Result<Expr, RuntimeError> {
+        self.consume(TokenKind::LeftParen, "Expected '(' after 'fn'.")?;
+        let mut params = Vec::new();
+        if !self.check(&TokenKind::RightParen) {
+            loop {
+                params.push(self.consume_ident("Expected parameter name.")?);
+                if !self.match_kind(&[TokenKind::Comma]) {
+                    break;
+                }
+            }
+        }
+        self.consume(TokenKind::RightParen, "Expected ')' after parameters.")?;
+        self.consume(TokenKind::LeftBrace, "Expected '{' before function body.")?;
+        let body = self.block()?;
+        Ok(Expr::Lambda { params, body })
+    }
+
+    fn if_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        self.consume(TokenKind::LeftParen, "Expected '(' after 'if'.")?;
+        let condition = self.expression()?;
+        self.consume(TokenKind::RightParen, "Expected ')' after condition.")?;
+
+        let then_branch = Box::new(self.statement()?);
+        let else_branch = if self.match_kind(&[TokenKind::Else]) {
+            Some(Box::new(self.statement()?))
+        } else {
+            None
+        };
+
+        Ok(Stmt::If { condition, then_branch, else_branch })
+    }
+
+    fn while_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        self.consume(TokenKind::LeftParen, "Expected '(' after 'while'.")?;
+        let condition = self.expression()?;
+        self.consume(TokenKind::RightParen, "Expected ')' after condition.")?;
+
+        let body = Box::new(self.statement()?);
+        Ok(Stmt::While { condition, body })
+    }
+
+    fn for_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        self.consume(TokenKind::LeftParen, "Expected '(' after 'for'.")?;
+
+        // Detect for-in: for (Identifier in expr) body
+        if let TokenKind::Identifier(var_name) = &self.peek().kind {
+            let var_name = var_name.clone();
+            if matches!(self.peek_next().kind, TokenKind::In) {
+                self.advance(); // consume identifier
+                self.advance(); // consume 'in'
+                let iterable = self.expression()?;
+                self.consume(TokenKind::RightParen, "Expected ')' after for-in expression.")?;
+                let body = Box::new(self.statement()?);
+                return Ok(Stmt::ForIn { var_name, iterable, body });
+            }
+        }
+
+        let initializer = if self.match_kind(&[TokenKind::Semicolon]) {
+            None
+        } else if self.match_kind(&[TokenKind::Let]) {
+            Some(self.let_declaration(true)?)
+        } else {
+            Some(self.expression_statement()?)
+        };
+
+        let condition = if !self.check(&TokenKind::Semicolon) {
+            Some(self.expression()?)
+        } else {
+            None
+        };
+
+        self.consume(TokenKind::Semicolon, "Expected ';' after loop condition.")?;
+        let step = if !self.check(&TokenKind::RightParen) {
+            Some(self.expression()?)
+        } else {
+            None
+        };
+
+        self.consume(TokenKind::RightParen, "Expected ')' after for clauses.")?;
+        let body = Box::new(self.statement()?);
+
+        Ok(Stmt::For {
+            initializer: initializer.map(Box::new),
+            condition,
+            step,
+            body
+        })
+    }
+
+    fn break_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        self.match_kind(&[TokenKind::Semicolon]); // 分号可选
+        Ok(Stmt::Break)
+    }
+
+    fn continue_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        self.match_kind(&[TokenKind::Semicolon]); // 分号可选
+        Ok(Stmt::Continue)
+    }
+
+    fn return_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        let value = if !self.check(&TokenKind::Semicolon) && !self.check(&TokenKind::RightBrace) {
+            Some(self.expression()?)
+        } else {
+            None
+        };
+
+        self.match_kind(&[TokenKind::Semicolon]); // 分号可选
+        Ok(Stmt::Return(value))
+    }
+
+    fn block(&mut self) -> Result<Vec<Stmt>, RuntimeError> {
+        let mut statements = Vec::new();
+
+        while !self.check(&TokenKind::RightBrace) && !self.is_at_end() {
+            statements.push(self.declaration()?);
+        }
+
+        self.consume(TokenKind::RightBrace, "Expected '}' after block.")?;
+        Ok(statements)
+    }
+
+    fn expression_statement(&mut self) -> Result<Stmt, RuntimeError> {
+        let expr = self.expression()?;
+        self.match_kind(&[TokenKind::Semicolon]); // 分号可选
+        Ok(Stmt::ExprStmt(expr))
+    }
+
+    fn expression(&mut self) -> Result<Expr, RuntimeError> {
+        self.assignment()
+    }
+
+    fn ternary(&mut self) -> Result<Expr, RuntimeError> {
+        let expr = self.logical_or()?;
+        if self.match_kind(&[TokenKind::Question]) {
+            let then_branch = self.assignment()?;
+            self.consume(TokenKind::Colon, "Expected ':' after then branch of ternary.")?;
+            let else_branch = self.assignment()?;
+            Ok(Expr::Ternary {
+                condition: Box::new(expr),
+                then_branch: Box::new(then_branch),
+                else_branch: Box::new(else_branch),
+            })
+        } else {
+            Ok(expr)
+        }
+    }
+
+    fn assignment(&mut self) -> Result<Expr, RuntimeError> {
+        let expr = self.ternary()?;
+
+        let op = if self.match_kind(&[TokenKind::Equal]) {
+            Some(AssignOp::Equal)
+        } else if self.match_kind(&[TokenKind::PlusEqual]) {
+            Some(AssignOp::PlusEqual)
+        } else if self.match_kind(&[TokenKind::MinusEqual]) {
+            Some(AssignOp::MinusEqual)
+        } else if self.match_kind(&[TokenKind::StarEqual]) {
+            Some(AssignOp::StarEqual)
+        } else if self.match_kind(&[TokenKind::SlashEqual]) {
+            Some(AssignOp::SlashEqual)
+        } else if self.match_kind(&[TokenKind::PercentEqual]) {
+            Some(AssignOp::PercentEqual)
+        } else {
+            None
+        };
+
+        if let Some(op) = op {
+            let value = self.assignment()?;
+            return match expr {
+                Expr::Variable(name) => Ok(Expr::Assign { name, op, value: Box::new(value) }),
+                Expr::Get { object, name } => Ok(Expr::Set { object, name, op, value: Box::new(value) }),
+                Expr::IndexGet { array, index } => Ok(Expr::IndexSet { array, index, op, value: Box::new(value) }),
+                _ => Err(RuntimeError::parse("Invalid assignment target.", self.previous().clone())),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn logical_or(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.logical_and()?;
+
+        while self.match_kind(&[TokenKind::OrOr]) {
+            let right = self.logical_and()?;
+            expr = Expr::Logical {
+                left: Box::new(expr),
+                op: LogicalOp::Or,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn logical_and(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.equality()?;
+
+        while self.match_kind(&[TokenKind::AndAnd]) {
+            let right = self.equality()?;
+            expr = Expr::Logical {
+                left: Box::new(expr),
+                op: LogicalOp::And,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn equality(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.comparison()?;
+
+        while self.match_kind(&[TokenKind::EqualEqual, TokenKind::BangEqual]) {
+            let op = match self.previous().kind {
+                TokenKind::EqualEqual => BinaryOp::Equal,
+                TokenKind::BangEqual => BinaryOp::NotEqual,
+                _ => unreachable!(),
+            };
+            let right = self.comparison()?;
+            expr = Expr::Binary {
+                left: Box::new(expr),
+                op,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn comparison(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.term()?;
+
+        while self.match_kind(&[TokenKind::Greater, TokenKind::GreaterEqual, TokenKind::Less, TokenKind::LessEqual]) {
+            let op = match self.previous().kind {
+                TokenKind::Greater => BinaryOp::Greater,
+                TokenKind::GreaterEqual => BinaryOp::GreaterEqual,
+                TokenKind::Less => BinaryOp::Less,
+                TokenKind::LessEqual => BinaryOp::LessEqual,
+                _ => unreachable!(),
+            };
+            let right = self.term()?;
+            expr = Expr::Binary {
+                left: Box::new(expr),
+                op,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn term(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.factor()?;
+
+        while self.match_kind(&[TokenKind::Plus, TokenKind::Minus]) {
+            let op = match self.previous().kind {
+                TokenKind::Plus => BinaryOp::Add,
+                TokenKind::Minus => BinaryOp::Sub,
+                _ => unreachable!(),
+            };
+            let right = self.factor()?;
+            expr = Expr::Binary {
+                left: Box::new(expr),
+                op,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn factor(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.unary()?;
+
+        while self.match_kind(&[TokenKind::Star, TokenKind::Slash, TokenKind::Percent]) {
+            let op = match self.previous().kind {
+                TokenKind::Star => BinaryOp::Mul,
+                TokenKind::Slash => BinaryOp::Div,
+                TokenKind::Percent => BinaryOp::Mod,
+                _ => unreachable!(),
+            };
+            let right = self.unary()?;
+            expr = Expr::Binary {
+                left: Box::new(expr),
+                op,
+                right: Box::new(right),
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn unary(&mut self) -> Result<Expr, RuntimeError> {
+        if self.match_kind(&[TokenKind::Bang, TokenKind::Minus]) {
+            let op = match self.previous().kind {
+                TokenKind::Bang => UnaryOp::Not,
+                TokenKind::Minus => UnaryOp::Negate,
+                _ => unreachable!(),
+            };
+            let right = self.unary()?;
+            return Ok(Expr::Unary {
+                op,
+                right: Box::new(right),
+            });
+        }
+
+        self.call()
+    }
+
+    fn call(&mut self) -> Result<Expr, RuntimeError> {
+        let mut expr = self.primary()?;
+
+        loop {
+            if self.match_kind(&[TokenKind::LeftParen]) {
+                let mut arguments = Vec::new();
+                if !self.check(&TokenKind::RightParen) {
+                    loop {
+                        arguments.push(self.expression()?);
+                        if !self.match_kind(&[TokenKind::Comma]) {
+                            break;
+                        }
+                    }
+                }
+                self.consume(TokenKind::RightParen, "Expected ')' after arguments.")?;
+                expr = Expr::Call {
+                    callee: Box::new(expr),
+                    arguments,
+                };
+            } else if self.match_kind(&[TokenKind::Dot]) {
+                let name = self.consume_ident("Expected property name after '.'.")?;
+                expr = Expr::Get {
+                    object: Box::new(expr),
+                    name,
+                };
+            } else if self.match_kind(&[TokenKind::LeftBracket]) {
+                let index = self.expression()?;
+                self.consume(TokenKind::RightBracket, "Expected ']' after index.")?;
+                expr = Expr::IndexGet {
+                    array: Box::new(expr),
+                    index: Box::new(index),
+                };
+            } else {
+                break;
+            }
+        }
+
+        Ok(expr)
+    }
+
+    fn primary(&mut self) -> Result<Expr, RuntimeError> {
+        // 布尔值
+        if self.match_kind(&[TokenKind::True]) {
+            return Ok(Expr::Literal(Literal::Bool(true)));
+        }
+        if self.match_kind(&[TokenKind::False]) {
+            return Ok(Expr::Literal(Literal::Bool(false)));
+        }
+        if self.match_kind(&[TokenKind::Nil]) {
+            return Ok(Expr::Literal(Literal::Nil));
+        }
+
+        // 数字
+        if let TokenKind::Number(n) = self.peek().kind {
+            self.advance();
+            return Ok(Expr::Literal(Literal::Number(n)));
+        }
+
+        // 字符串
+        if let TokenKind::String(s) = &self.peek().kind {
+            let s = s.clone();
+            self.advance();
+            return Ok(Expr::Literal(Literal::String(s)));
+        }
+
+        // 标识符（变量）
+        if let TokenKind::Identifier(name) = &self.peek().kind {
+            let name = name.clone();
+            self.advance();
+            return Ok(Expr::Variable(name));
+        }
+
+        // 匿名函数（闭包）: fn(params) { body }
+        if self.match_kind(&[TokenKind::Fn]) {
+            return self.lambda_expr();
+        }
+
+        // 括号表达式
+        if self.match_kind(&[TokenKind::LeftParen]) {
+            let expr = self.expression()?;
+            self.consume(TokenKind::RightParen, "Expected ')' after expression.")?;
+            return Ok(expr);
+        }
+
+        if self.match_kind(&[TokenKind::LeftBrace]) {
+            return self.object_literal();
+        }
+
+        if self.match_kind(&[TokenKind::LeftBracket]) {
+            return self.array_literal();
+        }
+
+        Err(RuntimeError::parse("Expected expression.", self.peek().clone()))
+    }
+
+    fn match_kind(&mut self, kinds: &[TokenKind]) -> bool {
+        for kind in kinds {
+            if self.check(kind) {
+                self.advance();
+                return true;
+            }
+        }
+        false
+    }
+
+    fn consume(&mut self, kind: TokenKind, msg: &str) -> Result<(), RuntimeError> {
+        if self.check(&kind) {
+            self.advance();
+            Ok(())
+        } else {
+            Err(RuntimeError::parse(msg, self.peek().clone()))
+        }
+    }
+
+    fn consume_ident(&mut self, msg: &str) -> Result<String, RuntimeError> {
+        match &self.peek().kind {
+            TokenKind::Identifier(name) => {
+                let name = name.clone();
+                self.advance();
+                Ok(name)
+            }
+            _ => Err(RuntimeError::parse(msg, self.peek().clone())),
+        }
+    }
+
+    fn check(&self, kind: &TokenKind) -> bool {
+        if self.is_at_end() {
+            return false;
+        }
+        std::mem::discriminant(&self.peek().kind)
+            == std::mem::discriminant(kind)
+    }
+
+    fn advance(&mut self) -> &Token {
+        if !self.is_at_end() {
+            self.current += 1;
+        }
+        self.previous()
+    }
+
+    fn is_at_end(&self) -> bool {
+        matches!(self.peek().kind, TokenKind::EOF)
+    }
+
+    fn peek(&self) -> &Token {
+        &self.tokens[self.current]
+    }
+
+    fn peek_next(&self) -> &Token {
+        &self.tokens[self.current + 1]
+    }
+
+    fn previous(&self) -> &Token {
+        &self.tokens[self.current - 1]
+    }
+
+    fn object_literal(&mut self) -> Result<Expr, RuntimeError> {
+        let mut properties = Vec::new();
+        if !self.check(&TokenKind::RightBrace) {
+            loop {
+                let name = self.consume_ident("Expected property name in object literal")?;
+                self.consume(TokenKind::Colon, "Expected ':' after property name in object literal")?;
+                let value = self.expression()?;
+                properties.push((name, value));
+                if !self.match_kind(&[TokenKind::Comma]) {
+                    break;
+                }
+                // Allow trailing comma
+                if self.check(&TokenKind::RightBrace) {
+                    break;
+                }
+            }
+        }
+        self.consume(TokenKind::RightBrace, "Expected '}' after object literal")?;
+        Ok(Expr::ObjectLiteral { properties })
+    }
+
+    fn array_literal(&mut self) -> Result<Expr, RuntimeError> {
+        let mut elements = Vec::new();
+        if !self.check(&TokenKind::RightBracket) {
+            loop {
+                elements.push(self.expression()?);
+                if !self.match_kind(&[TokenKind::Comma]) {
+                    break;
+                }
+                // Allow trailing comma
+                if self.check(&TokenKind::RightBracket) {
+                    break;
+                }
+            }
+        }
+        self.consume(TokenKind::RightBracket, "Expected ']' after array literal")?;
+        Ok(Expr::ArrayLiteral { elements })
+    }
+
+    fn synchronize(&mut self) {
+        // Always consume at least one token to guarantee forward progress,
+        // preventing infinite loops when previous() is already a semicolon.
+        if !self.is_at_end() {
+            self.advance();
+        }
+
+        while !self.is_at_end() {
+            if self.current > 0 && matches!(self.previous().kind, TokenKind::Semicolon) {
+                return;
+            }
+
+            match self.peek().kind {
+                TokenKind::Let
+                | TokenKind::Const
+                | TokenKind::Fn
+                | TokenKind::If
+                | TokenKind::While
+                | TokenKind::For
+                | TokenKind::Return
+                | TokenKind::Break
+                | TokenKind::Continue => return,
+                _ => {
+                    self.advance();
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "tests.rs"]
+mod tests;