Files
endorphin-aster-vm/crates/frontend/src/ast/visitor.rs
T

590 lines
30 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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(())
}