// parser.rs 编译时引入,生成 syntax 的 Token 解析规则;source 是这些 Token 对应的原始 UTF-8 文本。 // 规则只构造拥有文本及原文跨度的 AST,不解析名称/类型,也不执行函数或操作 VM。 peg::parser! { // parse/parse_expression/parse_ast 的交互分支调用相应公开根,默认要求完整消费 Token 输入。 grammar syntax(source: &str) for [Token] { // 各语法上下文按原文精确匹配 Name;词法器不把这些词全局保留为独立关键字种类。 rule keyword(word: &str) -> Span = [Token { kind: TokenKind::Name, span } if &source[span.start..span.end] == word] { span } // function 规则的开头;quiet 隐藏内部 Token 细节,失败期望显示可读的 function。 rule function_keyword() -> Span = quiet!{keyword("function")} / expected!("'function'") // binding 的开头,同样提供稳定可读的期望项。 rule let_keyword() -> Span = quiet!{keyword("let")} / expected!("'let'") // return_statement 的开头及 local_statement 的负向前瞻,避免 return 被普通表达式语句消费。 rule return_keyword() -> Span = quiet!{keyword("return")} / expected!("'return'") // 声明、类型名及表达式引用共用;从 Token 范围复制名称文本,AST 不借用原源码缓冲。 rule name() -> Name = span:quiet!{[Token { kind: TokenKind::Name, span }] { span }} { Name { text: source[span.start..span.end].into(), span } } / expected!("identifier") // 函数参数、调用及括号表达式复用左括号匹配,返回范围供组合节点使用。 rule lparen() -> Span = quiet!{[Token { kind: TokenKind::LeftParen, span }] { span }} / expected!("'('") // 参数/调用/括号表达式复用右括号匹配,其终点可成为完整表达式终点。 rule rparen() -> Span = quiet!{[Token { kind: TokenKind::RightParen, span }] { span }} / expected!("')'") // 类和 block 的左边界,缺失时报告可读的左花括号期望项。 rule lbrace() -> Span = quiet!{[Token { kind: TokenKind::LeftBrace, span }] { span }} / expected!("'{'") // 类和 block 的右边界,节点跨度包含这个闭合括号。 rule rbrace() -> Span = quiet!{[Token { kind: TokenKind::RightBrace, span }] { span }} / expected!("'}'") // 类型注解和类继承共用冒号,不额外构造 AST 节点。 rule colon() = quiet!{[Token { kind: TokenKind::Colon, .. }]} / expected!("':'") // 参数/实参列表分隔;列表组合器决定空列表及分隔规则。 rule comma() = quiet!{[Token { kind: TokenKind::Comma, .. }]} / expected!("','") // 绑定和赋值共用单等号 Token,不接受相等比较 Token。 rule equal() = quiet!{[Token { kind: TokenKind::Equal, .. }]} / expected!("'='") // 成员后缀和符号字面量共用点,返回其范围以保留符号起点。 rule dot() -> Span = quiet!{[Token { kind: TokenKind::Dot, span }] { span }} / expected!("'.'") // 加法优先级层消费 Plus Token。 rule plus() = [Token { kind: TokenKind::Plus, .. }] // 减法及一元取负共用 Minus,前缀负号需要它的跨度作为节点起点。 rule minus() -> Span = [Token { kind: TokenKind::Minus, span }] { span } // 乘法优先级层消费 Star Token。 rule star() = [Token { kind: TokenKind::Star, .. }] // 除法优先级层消费 Slash,注释已在词法 trivia 中跳过。 rule slash() = [Token { kind: TokenKind::Slash, .. }] // parse 的模块入口;至少一个顶层函数或类声明,默认拒绝剩余 Token。 pub rule program() -> Program = declarations:declaration()+ { // 声明列表由 + 保证非空,根范围从首声明起点延伸到末声明终点。 let span = declarations[0].span.through(declarations.last().unwrap().span); Program { declarations, span } } // program/interactive_statement 的声明分支;函数直接包装,类则收集基类及成员。 rule declaration() -> Decl = function:function() { Decl { span: function.span, kind: DeclKind::Function(function) } } / start:keyword("class") name:name() base:(colon() base:name() { base })? lbrace() members:class_member()* end:rbrace() { // 按字段出现顺序收集字段参数结构,类的布局稍后由编译器及 VM 解释。 let mut fields = Vec::new(); // 按方法出现顺序收集函数结构,与字段分开存储但不改变各自顺序。 let mut methods = Vec::new(); // 解析阶段先统一取得成员,再按中间分类分发到两份 AST 列表。 for member in members { // 字段和方法保留各自原节点及跨度,不在这里检查成员重名或 self。 match member { ClassMember::Field(field) => fields.push(field), ClassMember::Method(method) => methods.push(method), } } // 类范围包括 class 开头与闭合花括号,中间空白/注释仍属于原文范围。 let span = start.through(end); Decl { span, kind: DeclKind::Class(Class { name, base, fields, methods, span }) } } // declaration 的类体调用,先尝试完整方法,再尝试名称加类型的字段。 rule class_member() -> ClassMember = function:function() { ClassMember::Method(function) } / field:parameter() { ClassMember::Field(field) } // parse_ast 的交互入口;恰好一个完整语句包装为列表,不管理多次提交的环境。 pub rule interactive() -> InteractiveInput = statement:interactive_statement() { InteractiveInput { span: statement.span, statements: vec![statement] } } // 交互允许声明、控制流、let、属性/普通赋值及表达式,不提供根级 return。 rule interactive_statement() -> Stmt = declaration:declaration() { Stmt { span: declaration.span, kind: StmtKind::Declaration(declaration) } } / control:control_statement() { control } / binding:binding() { binding_statement(binding) } / assignment:member_assignment() { assignment } / assignment:assignment() { assignment } / expression:expression() { Stmt { span: expression.span, kind: StmtKind::Expression(expression) } } // 顶层和类方法共用函数语法,显式参数类型、返回类型及函数体;self 合法性留给分析。 rule function() -> Function = start:function_keyword() name:name() lparen() parameters:(parameter() ** comma()) rparen() colon() return_type:name() body:block() { Function { span: start.through(body.span), name, parameters, return_type, body } } // 函数参数或类字段共用名称/类型名节点,语法只保留注解文本而不解析类型身份。 rule parameter() -> Parameter = name:name() colon() type_name:name() { Parameter { span: name.span.through(type_name.span), name, type_name } } // function 和控制流共用块语法,普通语句后可接一个末尾 return;return 当前要求表达式。 rule block() -> Block = start:lbrace() locals:local_statement()* returned:return_statement()? end:rbrace() { // 先保留普通语句序列,下面仅在存在末尾 return 时追加,保持源码顺序。 let mut statements = locals; // 可选 return 不会被当作普通表达式消费,也不能后接其他块内语句。 if let Some(returned) = returned { statements.push(returned); } Block { statements, span: start.through(end) } } // 块内语句分派;成员赋值先于普通赋值,最后表达式分支显式排除 return 前缀。 rule local_statement() -> Stmt = control:control_statement() { control } / binding:binding() { binding_statement(binding) } / assignment:member_assignment() { assignment } / assignment:assignment() { assignment } / !return_keyword() expression:expression() { Stmt { span: expression.span, kind: StmtKind::Expression(expression) } } // 交互或块内解析 if/else、while,条件和嵌套 block 都保留为语法树,尚不推断初始化。 rule control_statement() -> Stmt = start:keyword("if") condition:expression() body:block() otherwise:(keyword("else") body:block() { body })? { // if 范围有 else 时延伸到 else 块末尾,否则只延伸到 then 块末尾。 let span=start.through(otherwise.as_ref().map_or(body.span,|b|b.span)); Stmt {span,kind:StmtKind::If(IfStatement {condition,body,otherwise,span})} } / start:keyword("while") condition:expression() body:block() { // while 范围覆盖关键字、条件及整个循环体。 let span=start.through(body.span); Stmt {span,kind:StmtKind::While(WhileStatement {condition,body,span})} } // 交互或局部普通赋值;允许语法上未声明目标,具体全局/局部规则由 compiler::analyze 决定。 rule assignment() -> Stmt = name:name() equal() value:expression() { // 赋值语句的原文范围从目标名延伸到右值末尾。 let span = name.span.through(value.span); Stmt { span, kind: StmtKind::Assignment(Assignment { name, value, span }) } } // 先解析后缀目标再检查其最外层确为 Member;错误目标使本规则失败,不执行对象写入。 rule member_assignment() -> Stmt = target:postfix_expression() equal() value:expression() {? // 属性赋值保留整个接收对象/属性链及右值的原文范围。 let span = target.span.through(value.span); // 只有成员访问可拆成接收对象与字段名,裸名字留给普通赋值分支识别。 match target.kind { ExprKind::Member { object, name } => Ok(Stmt { span, kind: StmtKind::MemberAssignment(MemberAssignment { object: *object, name, value, span }), }), _ => Err("member assignment target"), } } // 交互/局部 let 绑定,范围包括 let 关键字;重复名和右值初始化检查在后续语义分析。 rule binding() -> Binding = start:let_keyword() name:name() equal() value:expression() { Binding { span: start.through(value.span), name, value } } // block 的可选末尾返回,语法要求一个表达式,构造 ReturnStatement 的 Some 值。 rule return_statement() -> Stmt = start:return_keyword() value:expression() { // return 范围从关键字到返回表达式末尾,包括其间空白。 let span = start.through(value.span); Stmt { span, kind: StmtKind::Return(ReturnStatement { value: Some(value), span }) } } // parse_expression 公开入口及各子表达式共用;precedence 层由低到高组织,二元操作在同层左结合。 pub rule expression() -> Expr = precedence! { // 比较层优先级最低;六种比较均复用 binary 包装左右节点和范围。 left:(@) [Token {kind:TokenKind::EqualEqual,..}] right:@ {binary(left,BinaryOp::Equal,right)} left:(@) [Token {kind:TokenKind::NotEqual,..}] right:@ {binary(left,BinaryOp::NotEqual,right)} left:(@) [Token {kind:TokenKind::Less,..}] right:@ {binary(left,BinaryOp::Less,right)} left:(@) [Token {kind:TokenKind::LessEqual,..}] right:@ {binary(left,BinaryOp::LessEqual,right)} left:(@) [Token {kind:TokenKind::Greater,..}] right:@ {binary(left,BinaryOp::Greater,right)} left:(@) [Token {kind:TokenKind::GreaterEqual,..}] right:@ {binary(left,BinaryOp::GreaterEqual,right)} -- // 加减层高于比较、低于乘除,同层按左结合嵌套。 left:(@) plus() right:@ { binary(left, BinaryOp::Add, right) } left:(@) minus() right:@ { binary(left, BinaryOp::Subtract, right) } -- // 乘除层先构造节点,再交给外围的加减/比较层。 left:(@) star() right:@ { binary(left, BinaryOp::Multiply, right) } left:(@) slash() right:@ { binary(left, BinaryOp::Divide, right) } -- // 前缀 await 构造等待节点,是否允许停放由执行上下文决定。 start:keyword("await") operand:@ { Expr { span: start.through(operand.span), kind: ExprKind::Await(Box::new(operand)) } } // 前缀取负包住当前高优先级操作数,不在语法阶段计算数值。 start:minus() operand:@ { Expr { span: start.through(operand.span), kind: ExprKind::Unary { operation: UnaryOp::Negate, operand: Box::new(operand) } } } -- // 后缀表达式位于最高优先级层,先形成调用/成员链,再被一元或二元节点包裹。 expression:postfix_expression() { expression } } // 优先级最高的 primary 后接零或多个成员/调用后缀,从左到右 fold 保持链式求值结构。 rule postfix_expression() -> Expr = expression:primary() suffixes:suffix()* { // parser::postfix 每次把先前结果作为接收对象或被调用表达式,构造 a.b(c).d 一类链。 suffixes.into_iter().fold(expression, postfix) } // postfix_expression 共用后缀;点后取 Name,调用保存参数列表及右括号范围。 rule suffix() -> Suffix = dot() name:name() { Suffix::Member(name) } / lparen() arguments:(expression() ** comma()) end:rparen() { Suffix::Call(arguments, end) } // 原子表达式:括号、符号、数字、字符串或名称;AST 文本均从匹配 Token 原文复制/解码。 rule primary() -> Expr = start:lparen() expression:expression() end:rparen() { // 括号不新增语义节点种类,只把子表达式范围扩大到两侧括号。 Expr { span: start.through(end), ..expression } } / start:dot() name:name() { // 点开头的符号与成员后缀不同;前端保留它,编译器当前尚不支持生成该运行时值。 Expr { span: start.through(name.span), kind: ExprKind::Symbol(name) } } / [Token { kind: TokenKind::Number, span }] { // 数值保存原始十进制拼写,精确解析与负号处理留给 codegen。 Expr { span, kind: ExprKind::Number(source[span.start..span.end].into()) } } / [Token { kind: TokenKind::String, span }] { // Token 跨度含引号,去掉引号后调用已验证转义的 decode_string,AST 保存解码结果。 Expr { span, kind: ExprKind::String(decode_string(&source[span.start + 1..span.end - 1])) } } / name:name() { Expr { span: name.span, kind: ExprKind::Name(name.text) } } } }