Module syn::visit [−][src]
Expand description
Syntax tree traversal to walk a shared borrow of a syntax tree.
Each method of the Visit trait is a hook that can be overridden to
customize the behavior when visiting the corresponding type of node. By
default, every method recursively visits the substructure of the input
by invoking the right visitor method of each of its fields.
pub trait Visit<'ast> {
/* ... */
fn visit_expr_binary(&mut self, node: &'ast ExprBinary) {
visit_expr_binary(self, node);
}
/* ... */
}
pub fn visit_expr_binary<'ast, V>(v: &mut V, node: &'ast ExprBinary)
where
V: Visit<'ast> + ?Sized,
{
for attr in &node.attrs {
v.visit_attribute(attr);
}
v.visit_expr(&*node.left);
v.visit_bin_op(&node.op);
v.visit_expr(&*node.right);
}
/* ... */This module is available only if Syn is built with the "visit" feature.
Example
This visitor will print the name of every freestanding function in the syntax tree, including nested functions.
// [dependencies]
// quote = "1.0"
// syn = { version = "1.0", features = ["full", "visit"] }
use quote::quote;
use syn::visit::{self, Visit};
use syn::{File, ItemFn};
struct FnVisitor;
impl<'ast> Visit<'ast> for FnVisitor {
fn visit_item_fn(&mut self, node: &'ast ItemFn) {
println!("Function with name={}", node.sig.ident);
// Delegate to the default impl to visit any nested functions.
visit::visit_item_fn(self, node);
}
}
fn main() {
let code = quote! {
pub fn f() {
fn g() {}
}
};
let syntax_tree: File = syn::parse2(code).unwrap();
FnVisitor.visit_file(&syntax_tree);
}The 'ast lifetime on the input references means that the syntax tree
outlives the complete recursive visit call, so the visitor is allowed to
hold on to references into the syntax tree.
use quote::quote;
use syn::visit::{self, Visit};
use syn::{File, ItemFn};
struct FnVisitor<'ast> {
functions: Vec<&'ast ItemFn>,
}
impl<'ast> Visit<'ast> for FnVisitor<'ast> {
fn visit_item_fn(&mut self, node: &'ast ItemFn) {
self.functions.push(node);
visit::visit_item_fn(self, node);
}
}
fn main() {
let code = quote! {
pub fn f() {
fn g() {}
}
};
let syntax_tree: File = syn::parse2(code).unwrap();
let mut visitor = FnVisitor { functions: Vec::new() };
visitor.visit_file(&syntax_tree);
for f in visitor.functions {
println!("Function with name={}", f.sig.ident);
}
}Traits
Syntax tree traversal to walk a shared borrow of a syntax tree.