590 lines
30 KiB
Rust
590 lines
30 KiB
Rust
// Generated by scripts/generate_ast.py from Endor.asdl. Do not edit.
|
||
|
||
use super::{
|
||
Assignment, AstDocument, AstRoot, BinaryOp, Binding, Block, Class, Decl, DeclKind, Expr,
|
||
ExprKind, Function, IfStatement, InteractiveInput, MemberAssignment, Name, Parameter, Program,
|
||
ReturnStatement, Spanned, Stmt, StmtKind, UnaryOp, WhileStatement,
|
||
};
|
||
use crate::Span;
|
||
/// wire 校验与宿主分析实现的借用节点访问协议;默认按 ASDL 字段顺序递归,不修改树。
|
||
/// 覆盖 visit 方法后可显式调用对应 walk 继续子遍历;walk 本身不执行当前节点的进入/退出钩子。
|
||
pub trait Visitor {
|
||
/// 实现者选择的错误类型,任一子访问失败即向上返回。
|
||
type Error;
|
||
/// 默认可定位 visit 在遍历前调用;失败时本节点尚未成功进入,不再调用它的 leave_node。
|
||
fn enter_node(&mut self, _span: Span) -> Result<(), Self::Error> {
|
||
Ok(())
|
||
}
|
||
/// 已成功进入节点的遍历结束后调用,子节点错误也需退出;默认无操作。
|
||
fn leave_node(&mut self) {}
|
||
/// walk 遇到显式 span 字段时调用,默认不处理;区别于围绕整个节点的 enter_node。
|
||
fn visit_span(&mut self, _span: &Span) -> Result<(), Self::Error> {
|
||
Ok(())
|
||
}
|
||
/// 上层 walk 或宿主调用的 AstDocument 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_ast_document(&mut self, node: &AstDocument) -> Result<(), Self::Error> {
|
||
walk_ast_document(self, node)
|
||
}
|
||
/// 上层 walk 或宿主调用的 AstRoot 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_ast_root(&mut self, node: &AstRoot) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_ast_root(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Name 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_name(&mut self, node: &Name) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_name(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Program 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_program(&mut self, node: &Program) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_program(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Decl 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_decl(&mut self, node: &Decl) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_decl(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 DeclKind 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_decl_kind(&mut self, node: &DeclKind) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_decl_kind(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Class 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_class(&mut self, node: &Class) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_class(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Function 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_function(&mut self, node: &Function) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_function(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Parameter 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_parameter(&mut self, node: &Parameter) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_parameter(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Block 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_block(&mut self, node: &Block) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_block(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Stmt 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_stmt(&mut self, node: &Stmt) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_stmt(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 StmtKind 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_stmt_kind(&mut self, node: &StmtKind) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_stmt_kind(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Binding 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_binding(&mut self, node: &Binding) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_binding(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Assignment 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_assignment(&mut self, node: &Assignment) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_assignment(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 MemberAssignment 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_member_assignment(&mut self, node: &MemberAssignment) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_member_assignment(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 IfStatement 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_if_statement(&mut self, node: &IfStatement) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_if_statement(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 WhileStatement 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_while_statement(&mut self, node: &WhileStatement) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_while_statement(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 ReturnStatement 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_return_statement(&mut self, node: &ReturnStatement) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_return_statement(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 InteractiveInput 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_interactive_input(&mut self, node: &InteractiveInput) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_interactive_input(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 Expr 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_expr(&mut self, node: &Expr) -> Result<(), Self::Error> {
|
||
// 先进入;进入失败则不启动子遍历。
|
||
self.enter_node(node.span())?;
|
||
// 保存子遍历结果,不在此使用 ?,确保失败时仍退出已进入节点。
|
||
let result = walk_expr(self, node);
|
||
self.leave_node();
|
||
result
|
||
}
|
||
/// 上层 walk 或宿主调用的 ExprKind 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_expr_kind(&mut self, node: &ExprKind) -> Result<(), Self::Error> {
|
||
walk_expr_kind(self, node)
|
||
}
|
||
/// 上层 walk 或宿主调用的 UnaryOp 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_unary_op(&mut self, node: &UnaryOp) -> Result<(), Self::Error> {
|
||
walk_unary_op(self, node)
|
||
}
|
||
/// 上层 walk 或宿主调用的 BinaryOp 入口;默认继续对应子结构,可覆盖此方法收集/校验节点。
|
||
fn visit_binary_op(&mut self, node: &BinaryOp) -> Result<(), Self::Error> {
|
||
walk_binary_op(self, node)
|
||
}
|
||
}
|
||
/// 默认 visit_ast_document 或自定义访问器调用,按字段顺序借用 AstDocument 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_ast_document<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &AstDocument,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.root 的 AstRoot 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_ast_root(&node.root)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_ast_root 或自定义访问器调用,按字段顺序借用 AstRoot 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_ast_root<V: Visitor + ?Sized>(visitor: &mut V, node: &AstRoot) -> Result<(), V::Error> {
|
||
// 按构造器只递归当前实际载荷,字符串等标量没有语法子节点。
|
||
match node {
|
||
// 模块根,包含函数/类声明。
|
||
AstRoot::Module(value) => {
|
||
// 访问 value 的 Program 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_program(value)?;
|
||
}
|
||
// 表达式根,编译后直接返回求值结果。
|
||
AstRoot::Expression(value) => {
|
||
// 访问 value 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(value)?;
|
||
}
|
||
// 交互根,包含一次完整提交。
|
||
AstRoot::Interactive(value) => {
|
||
// 访问 value 的 InteractiveInput 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_interactive_input(value)?;
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_name 或自定义访问器调用,按字段顺序借用 Name 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_name<V: Visitor + ?Sized>(visitor: &mut V, node: &Name) -> Result<(), V::Error> {
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_program 或自定义访问器调用,按字段顺序借用 Program 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_program<V: Visitor + ?Sized>(visitor: &mut V, node: &Program) -> Result<(), V::Error> {
|
||
// 按顺序借用 &node.declarations 中每个 Decl,任一访问失败立即向上传播。
|
||
for value in &node.declarations {
|
||
visitor.visit_decl(value)?;
|
||
}
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_decl 或自定义访问器调用,按字段顺序借用 Decl 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_decl<V: Visitor + ?Sized>(visitor: &mut V, node: &Decl) -> Result<(), V::Error> {
|
||
// 访问 &node.kind 的 DeclKind 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_decl_kind(&node.kind)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_decl_kind 或自定义访问器调用,按字段顺序借用 DeclKind 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_decl_kind<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &DeclKind,
|
||
) -> Result<(), V::Error> {
|
||
// 按构造器只递归当前实际载荷,字符串等标量没有语法子节点。
|
||
match node {
|
||
// 显式参数/返回注解与函数体,compiler 生成独立模板及源码签名;解析本身不调用函数。
|
||
DeclKind::Function(value) => {
|
||
// 访问 value 的 Function 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_function(value)?;
|
||
}
|
||
// 类名、可选基类、字段和方法,compiler 检查成员后生成构类指令。
|
||
DeclKind::Class(value) => {
|
||
// 访问 value 的 Class 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_class(value)?;
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_class 或自定义访问器调用,按字段顺序借用 Class 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_class<V: Visitor + ?Sized>(visitor: &mut V, node: &Class) -> Result<(), V::Error> {
|
||
// 访问 &node.name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.name)?;
|
||
// &node.base 是可选字段,仅 Some 时访问其 Name 子节点。
|
||
if let Some(value) = &node.base {
|
||
visitor.visit_name(value)?;
|
||
}
|
||
// 按顺序借用 &node.fields 中每个 Parameter,任一访问失败立即向上传播。
|
||
for value in &node.fields {
|
||
visitor.visit_parameter(value)?;
|
||
}
|
||
// 按顺序借用 &node.methods 中每个 Function,任一访问失败立即向上传播。
|
||
for value in &node.methods {
|
||
visitor.visit_function(value)?;
|
||
}
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_function 或自定义访问器调用,按字段顺序借用 Function 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_function<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &Function,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.name)?;
|
||
// 按顺序借用 &node.parameters 中每个 Parameter,任一访问失败立即向上传播。
|
||
for value in &node.parameters {
|
||
visitor.visit_parameter(value)?;
|
||
}
|
||
// 访问 &node.return_type 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.return_type)?;
|
||
// 访问 &node.body 的 Block 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_block(&node.body)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_parameter 或自定义访问器调用,按字段顺序借用 Parameter 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_parameter<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &Parameter,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.name)?;
|
||
// 访问 &node.type_name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.type_name)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_block 或自定义访问器调用,按字段顺序借用 Block 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_block<V: Visitor + ?Sized>(visitor: &mut V, node: &Block) -> Result<(), V::Error> {
|
||
// 按顺序借用 &node.statements 中每个 Stmt,任一访问失败立即向上传播。
|
||
for value in &node.statements {
|
||
visitor.visit_stmt(value)?;
|
||
}
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_stmt 或自定义访问器调用,按字段顺序借用 Stmt 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_stmt<V: Visitor + ?Sized>(visitor: &mut V, node: &Stmt) -> Result<(), V::Error> {
|
||
// 访问 &node.kind 的 StmtKind 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_stmt_kind(&node.kind)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_stmt_kind 或自定义访问器调用,按字段顺序借用 StmtKind 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_stmt_kind<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &StmtKind,
|
||
) -> Result<(), V::Error> {
|
||
// 按构造器只递归当前实际载荷,字符串等标量没有语法子节点。
|
||
match node {
|
||
// let 新绑定,compiler 检查重名并分析右值后才标记目标已初始化。
|
||
StmtKind::Binding(value) => {
|
||
// 访问 value 的 Binding 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_binding(value)?;
|
||
}
|
||
// 普通名称赋值,compiler 按作用域写局部槽或全局环境。
|
||
StmtKind::Assignment(value) => {
|
||
// 访问 value 的 Assignment 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_assignment(value)?;
|
||
}
|
||
// 成员写入的对象、属性名与右值,compiler 生成 StoreAttr。
|
||
StmtKind::MemberAssignment(value) => {
|
||
// 访问 value 的 MemberAssignment 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_member_assignment(value)?;
|
||
}
|
||
// 条件、then 和可选 else,compiler 合并继续路径的初始化集合并生成跳转。
|
||
StmtKind::If(value) => {
|
||
// 访问 value 的 IfStatement 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_if_statement(value)?;
|
||
}
|
||
// 循环条件与体,compiler 生成回边并处理循环可能零次执行。
|
||
StmtKind::While(value) => {
|
||
// 访问 value 的 WhileStatement 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_while_statement(value)?;
|
||
}
|
||
// 函数返回,compiler 对缺省值补 Nil;当前源码语法要求 return 后有表达式。
|
||
StmtKind::Return(value) => {
|
||
// 访问 value 的 ReturnStatement 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_return_statement(value)?;
|
||
}
|
||
// 表达式载荷及完整范围,compiler 生成留下一个结果的求值序列。
|
||
StmtKind::Expression(value) => {
|
||
// 访问 value 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(value)?;
|
||
}
|
||
// 顶层/交互声明的种类及完整范围,compiler 按函数或类分派。
|
||
StmtKind::Declaration(value) => {
|
||
// 访问 value 的 Decl 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_decl(value)?;
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_binding 或自定义访问器调用,按字段顺序借用 Binding 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_binding<V: Visitor + ?Sized>(visitor: &mut V, node: &Binding) -> Result<(), V::Error> {
|
||
// 访问 &node.name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.name)?;
|
||
// 访问 &node.value 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(&node.value)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_assignment 或自定义访问器调用,按字段顺序借用 Assignment 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_assignment<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &Assignment,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.name)?;
|
||
// 访问 &node.value 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(&node.value)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_member_assignment 或自定义访问器调用,按字段顺序借用 MemberAssignment 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_member_assignment<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &MemberAssignment,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.object 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(&node.object)?;
|
||
// 访问 &node.name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(&node.name)?;
|
||
// 访问 &node.value 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(&node.value)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_if_statement 或自定义访问器调用,按字段顺序借用 IfStatement 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_if_statement<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &IfStatement,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.condition 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(&node.condition)?;
|
||
// 访问 &node.body 的 Block 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_block(&node.body)?;
|
||
// &node.otherwise 是可选字段,仅 Some 时访问其 Block 子节点。
|
||
if let Some(value) = &node.otherwise {
|
||
visitor.visit_block(value)?;
|
||
}
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_while_statement 或自定义访问器调用,按字段顺序借用 WhileStatement 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_while_statement<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &WhileStatement,
|
||
) -> Result<(), V::Error> {
|
||
// 访问 &node.condition 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(&node.condition)?;
|
||
// 访问 &node.body 的 Block 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_block(&node.body)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_return_statement 或自定义访问器调用,按字段顺序借用 ReturnStatement 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_return_statement<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &ReturnStatement,
|
||
) -> Result<(), V::Error> {
|
||
// &node.value 是可选字段,仅 Some 时访问其 Expr 子节点。
|
||
if let Some(value) = &node.value {
|
||
visitor.visit_expr(value)?;
|
||
}
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_interactive_input 或自定义访问器调用,按字段顺序借用 InteractiveInput 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_interactive_input<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &InteractiveInput,
|
||
) -> Result<(), V::Error> {
|
||
// 按顺序借用 &node.statements 中每个 Stmt,任一访问失败立即向上传播。
|
||
for value in &node.statements {
|
||
visitor.visit_stmt(value)?;
|
||
}
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_expr 或自定义访问器调用,按字段顺序借用 Expr 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_expr<V: Visitor + ?Sized>(visitor: &mut V, node: &Expr) -> Result<(), V::Error> {
|
||
// 访问 &node.kind 的 ExprKind 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr_kind(&node.kind)?;
|
||
// 访问 &node.span 的 span 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_span(&node.span)?;
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_expr_kind 或自定义访问器调用,按字段顺序借用 ExprKind 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_expr_kind<V: Visitor + ?Sized>(
|
||
visitor: &mut V,
|
||
node: &ExprKind,
|
||
) -> Result<(), V::Error> {
|
||
// 按构造器只递归当前实际载荷,字符串等标量没有语法子节点。
|
||
match node {
|
||
// 变量引用文本,compiler 决定局部槽或全局索引。
|
||
ExprKind::Name(_) => {}
|
||
// 原始十进制拼写,保留全部位数、前导零及尾零,不转浮点。
|
||
ExprKind::Number(_) => {}
|
||
// 已解码受支持转义的拥有文本,原引号范围在外层 Expr。
|
||
ExprKind::String(_) => {}
|
||
// 点开头的符号名,前端可表示,当前 compiler 拒绝生成运行时值。
|
||
ExprKind::Symbol(value) => {
|
||
// 访问 value 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(value)?;
|
||
}
|
||
// 等待子表达式,VM 执行上下文决定是否允许停放。
|
||
ExprKind::Await(value) => {
|
||
// 访问 value 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(value)?;
|
||
}
|
||
// 一元取负,可在纯数值链上合并符号。
|
||
ExprKind::Unary {
|
||
operation, operand, ..
|
||
} => {
|
||
// 访问 operation 的 UnaryOp 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_unary_op(operation)?;
|
||
// 访问 operand 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(operand)?;
|
||
}
|
||
// 左右操作数及算术/比较种类,保留解析优先级树。
|
||
ExprKind::Binary {
|
||
operation,
|
||
left,
|
||
right,
|
||
..
|
||
} => {
|
||
// 访问 operation 的 BinaryOp 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_binary_op(operation)?;
|
||
// 访问 left 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(left)?;
|
||
// 访问 right 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(right)?;
|
||
}
|
||
// 接收对象及属性名的读取。
|
||
ExprKind::Member { object, name, .. } => {
|
||
// 访问 object 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(object)?;
|
||
// 访问 name 的 Name 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_name(name)?;
|
||
}
|
||
// 被调用表达式与位置实参,由 VM 实际求值。
|
||
ExprKind::Call {
|
||
callee, arguments, ..
|
||
} => {
|
||
// 访问 callee 的 Expr 子结构或跨度,借用不转移节点所有权。
|
||
visitor.visit_expr(callee)?;
|
||
// 按顺序借用 arguments 中每个 Expr,任一访问失败立即向上传播。
|
||
for value in arguments {
|
||
visitor.visit_expr(value)?;
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_unary_op 或自定义访问器调用,按字段顺序借用 UnaryOp 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_unary_op<V: Visitor + ?Sized>(
|
||
_visitor: &mut V,
|
||
_node: &UnaryOp,
|
||
) -> Result<(), V::Error> {
|
||
Ok(())
|
||
}
|
||
/// 默认 visit_binary_op 或自定义访问器调用,按字段顺序借用 BinaryOp 的子结构;本函数不进入/退出当前节点。
|
||
pub fn walk_binary_op<V: Visitor + ?Sized>(
|
||
_visitor: &mut V,
|
||
_node: &BinaryOp,
|
||
) -> Result<(), V::Error> {
|
||
Ok(())
|
||
}
|