diff options
Diffstat (limited to 'src/libsyntax/visit.rs')
| -rw-r--r-- | src/libsyntax/visit.rs | 249 |
1 files changed, 133 insertions, 116 deletions
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 51e7fa1eb38..d6573a06647 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -15,7 +15,7 @@ use crate::ast::*; use crate::token::Token; -use crate::tokenstream::{TokenTree, TokenStream}; +use crate::tokenstream::{TokenStream, TokenTree}; use syntax_pos::Span; @@ -60,33 +60,67 @@ pub trait Visitor<'ast>: Sized { fn visit_mod(&mut self, m: &'ast Mod, _s: Span, _attrs: &[Attribute], _n: NodeId) { walk_mod(self, m); } - fn visit_foreign_item(&mut self, i: &'ast ForeignItem) { walk_foreign_item(self, i) } - fn visit_global_asm(&mut self, ga: &'ast GlobalAsm) { walk_global_asm(self, ga) } - fn visit_item(&mut self, i: &'ast Item) { walk_item(self, i) } - fn visit_local(&mut self, l: &'ast Local) { walk_local(self, l) } - fn visit_block(&mut self, b: &'ast Block) { walk_block(self, b) } - fn visit_stmt(&mut self, s: &'ast Stmt) { walk_stmt(self, s) } - fn visit_param(&mut self, param: &'ast Param) { walk_param(self, param) } - fn visit_arm(&mut self, a: &'ast Arm) { walk_arm(self, a) } - fn visit_pat(&mut self, p: &'ast Pat) { walk_pat(self, p) } - fn visit_anon_const(&mut self, c: &'ast AnonConst) { walk_anon_const(self, c) } - fn visit_expr(&mut self, ex: &'ast Expr) { walk_expr(self, ex) } - fn visit_expr_post(&mut self, _ex: &'ast Expr) { } - fn visit_ty(&mut self, t: &'ast Ty) { walk_ty(self, t) } + fn visit_foreign_item(&mut self, i: &'ast ForeignItem) { + walk_foreign_item(self, i) + } + fn visit_global_asm(&mut self, ga: &'ast GlobalAsm) { + walk_global_asm(self, ga) + } + fn visit_item(&mut self, i: &'ast Item) { + walk_item(self, i) + } + fn visit_local(&mut self, l: &'ast Local) { + walk_local(self, l) + } + fn visit_block(&mut self, b: &'ast Block) { + walk_block(self, b) + } + fn visit_stmt(&mut self, s: &'ast Stmt) { + walk_stmt(self, s) + } + fn visit_param(&mut self, param: &'ast Param) { + walk_param(self, param) + } + fn visit_arm(&mut self, a: &'ast Arm) { + walk_arm(self, a) + } + fn visit_pat(&mut self, p: &'ast Pat) { + walk_pat(self, p) + } + fn visit_anon_const(&mut self, c: &'ast AnonConst) { + walk_anon_const(self, c) + } + fn visit_expr(&mut self, ex: &'ast Expr) { + walk_expr(self, ex) + } + fn visit_expr_post(&mut self, _ex: &'ast Expr) {} + fn visit_ty(&mut self, t: &'ast Ty) { + walk_ty(self, t) + } fn visit_generic_param(&mut self, param: &'ast GenericParam) { walk_generic_param(self, param) } - fn visit_generics(&mut self, g: &'ast Generics) { walk_generics(self, g) } + fn visit_generics(&mut self, g: &'ast Generics) { + walk_generics(self, g) + } fn visit_where_predicate(&mut self, p: &'ast WherePredicate) { walk_where_predicate(self, p) } fn visit_fn(&mut self, fk: FnKind<'ast>, fd: &'ast FnDecl, s: Span, _: NodeId) { walk_fn(self, fk, fd, s) } - fn visit_trait_item(&mut self, i: &'ast AssocItem) { walk_trait_item(self, i) } - fn visit_impl_item(&mut self, i: &'ast AssocItem) { walk_impl_item(self, i) } - fn visit_assoc_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) } - fn visit_trait_ref(&mut self, t: &'ast TraitRef) { walk_trait_ref(self, t) } + fn visit_trait_item(&mut self, i: &'ast AssocItem) { + walk_trait_item(self, i) + } + fn visit_impl_item(&mut self, i: &'ast AssocItem) { + walk_impl_item(self, i) + } + fn visit_assoc_item(&mut self, i: &'ast AssocItem) { + walk_assoc_item(self, i) + } + fn visit_trait_ref(&mut self, t: &'ast TraitRef) { + walk_trait_ref(self, t) + } fn visit_param_bound(&mut self, bounds: &'ast GenericBound) { walk_param_bound(self, bounds) } @@ -96,9 +130,16 @@ pub trait Visitor<'ast>: Sized { fn visit_variant_data(&mut self, s: &'ast VariantData) { walk_struct_def(self, s) } - fn visit_struct_field(&mut self, s: &'ast StructField) { walk_struct_field(self, s) } - fn visit_enum_def(&mut self, enum_definition: &'ast EnumDef, - generics: &'ast Generics, item_id: NodeId, _: Span) { + fn visit_struct_field(&mut self, s: &'ast StructField) { + walk_struct_field(self, s) + } + fn visit_enum_def( + &mut self, + enum_definition: &'ast EnumDef, + generics: &'ast Generics, + item_id: NodeId, + _: Span, + ) { walk_enum_def(self, enum_definition, generics, item_id) } fn visit_variant(&mut self, v: &'ast Variant) { @@ -215,10 +256,12 @@ pub fn walk_lifetime<'a, V: Visitor<'a>>(visitor: &mut V, lifetime: &'a Lifetime visitor.visit_ident(lifetime.ident); } -pub fn walk_poly_trait_ref<'a, V>(visitor: &mut V, - trait_ref: &'a PolyTraitRef, - _: &TraitBoundModifier) - where V: Visitor<'a>, +pub fn walk_poly_trait_ref<'a, V>( + visitor: &mut V, + trait_ref: &'a PolyTraitRef, + _: &TraitBoundModifier, +) where + V: Visitor<'a>, { walk_list!(visitor, visit_generic_param, &trait_ref.bound_generic_params); visitor.visit_trait_ref(&trait_ref.trait_ref); @@ -237,25 +280,22 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) { visitor.visit_name(item.span, orig_name); } } - ItemKind::Use(ref use_tree) => { - visitor.visit_use_tree(use_tree, item.id, false) - } - ItemKind::Static(ref typ, _, ref expr) | - ItemKind::Const(ref typ, ref expr) => { + ItemKind::Use(ref use_tree) => visitor.visit_use_tree(use_tree, item.id, false), + ItemKind::Static(ref typ, _, ref expr) | ItemKind::Const(ref typ, ref expr) => { visitor.visit_ty(typ); visitor.visit_expr(expr); } ItemKind::Fn(ref sig, ref generics, ref body) => { visitor.visit_generics(generics); visitor.visit_fn_header(&sig.header); - visitor.visit_fn(FnKind::ItemFn(item.ident, &sig.header, &item.vis, body), - &sig.decl, - item.span, - item.id) - } - ItemKind::Mod(ref module) => { - visitor.visit_mod(module, item.span, &item.attrs, item.id) - } + visitor.visit_fn( + FnKind::ItemFn(item.ident, &sig.header, &item.vis, body), + &sig.decl, + item.span, + item.id, + ) + } + ItemKind::Mod(ref module) => visitor.visit_mod(module, item.span, &item.attrs, item.id), ItemKind::ForeignMod(ref foreign_module) => { walk_list!(visitor, visit_foreign_item, &foreign_module.items); } @@ -268,18 +308,14 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) { visitor.visit_generics(generics); visitor.visit_enum_def(enum_definition, generics, item.id, item.span) } - ItemKind::Impl(_, _, _, - ref generics, - ref opt_trait_reference, - ref typ, - ref impl_items) => { + ItemKind::Impl(_, _, _, ref generics, ref opt_trait_reference, ref typ, ref impl_items) => { visitor.visit_generics(generics); walk_list!(visitor, visit_trait_ref, opt_trait_reference); visitor.visit_ty(typ); walk_list!(visitor, visit_impl_item, impl_items); } - ItemKind::Struct(ref struct_definition, ref generics) | - ItemKind::Union(ref struct_definition, ref generics) => { + ItemKind::Struct(ref struct_definition, ref generics) + | ItemKind::Union(ref struct_definition, ref generics) => { visitor.visit_generics(generics); visitor.visit_variant_data(struct_definition); } @@ -308,7 +344,8 @@ pub fn walk_enum_def<'a, V: Visitor<'a>>( } pub fn walk_variant<'a, V: Visitor<'a>>(visitor: &mut V, variant: &'a Variant) - where V: Visitor<'a>, +where + V: Visitor<'a>, { visitor.visit_ident(variant.ident); visitor.visit_vis(&variant.vis); @@ -331,12 +368,8 @@ pub fn walk_field_pattern<'a, V: Visitor<'a>>(visitor: &mut V, fp: &'a FieldPat) pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) { match typ.kind { - TyKind::Slice(ref ty) | TyKind::Paren(ref ty) => { - visitor.visit_ty(ty) - } - TyKind::Ptr(ref mutable_type) => { - visitor.visit_ty(&mutable_type.ty) - } + TyKind::Slice(ref ty) | TyKind::Paren(ref ty) => visitor.visit_ty(ty), + TyKind::Ptr(ref mutable_type) => visitor.visit_ty(&mutable_type.ty), TyKind::Rptr(ref opt_lifetime, ref mutable_type) => { walk_list!(visitor, visit_lifetime, opt_lifetime); visitor.visit_ty(&mutable_type.ty) @@ -358,19 +391,13 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) { visitor.visit_ty(ty); visitor.visit_anon_const(length) } - TyKind::TraitObject(ref bounds, ..) | - TyKind::ImplTrait(_, ref bounds) => { + TyKind::TraitObject(ref bounds, ..) | TyKind::ImplTrait(_, ref bounds) => { walk_list!(visitor, visit_param_bound, bounds); } - TyKind::Typeof(ref expression) => { - visitor.visit_anon_const(expression) - } + TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression), TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {} - TyKind::Mac(ref mac) => { - visitor.visit_mac(mac) - } - TyKind::Never | - TyKind::CVarArgs => {} + TyKind::Mac(ref mac) => visitor.visit_mac(mac), + TyKind::Never | TyKind::CVarArgs => {} } } @@ -380,9 +407,7 @@ pub fn walk_path<'a, V: Visitor<'a>>(visitor: &mut V, path: &'a Path) { } } -pub fn walk_use_tree<'a, V: Visitor<'a>>( - visitor: &mut V, use_tree: &'a UseTree, id: NodeId, -) { +pub fn walk_use_tree<'a, V: Visitor<'a>>(visitor: &mut V, use_tree: &'a UseTree, id: NodeId) { visitor.visit_path(&use_tree.prefix, id); match use_tree.kind { UseTreeKind::Simple(rename, ..) => { @@ -391,7 +416,7 @@ pub fn walk_use_tree<'a, V: Visitor<'a>>( visitor.visit_ident(rename); } } - UseTreeKind::Glob => {}, + UseTreeKind::Glob => {} UseTreeKind::Nested(ref use_trees) => { for &(ref nested_tree, nested_id) in use_trees { visitor.visit_use_tree(nested_tree, nested_id, true); @@ -400,19 +425,20 @@ pub fn walk_use_tree<'a, V: Visitor<'a>>( } } -pub fn walk_path_segment<'a, V: Visitor<'a>>(visitor: &mut V, - path_span: Span, - segment: &'a PathSegment) { +pub fn walk_path_segment<'a, V: Visitor<'a>>( + visitor: &mut V, + path_span: Span, + segment: &'a PathSegment, +) { visitor.visit_ident(segment.ident); if let Some(ref args) = segment.args { visitor.visit_generic_args(path_span, args); } } -pub fn walk_generic_args<'a, V>(visitor: &mut V, - _path_span: Span, - generic_args: &'a GenericArgs) - where V: Visitor<'a>, +pub fn walk_generic_args<'a, V>(visitor: &mut V, _path_span: Span, generic_args: &'a GenericArgs) +where + V: Visitor<'a>, { match *generic_args { GenericArgs::AngleBracketed(ref data) => { @@ -426,8 +452,10 @@ pub fn walk_generic_args<'a, V>(visitor: &mut V, } } -pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>(visitor: &mut V, - constraint: &'a AssocTyConstraint) { +pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>( + visitor: &mut V, + constraint: &'a AssocTyConstraint, +) { visitor.visit_ident(constraint.ident); match constraint.kind { AssocTyConstraintKind::Equality { ref ty } => { @@ -455,11 +483,9 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) { visitor.visit_path(path, pattern.id); walk_list!(visitor, visit_field_pattern, fields); } - PatKind::Box(ref subpattern) | - PatKind::Ref(ref subpattern, _) | - PatKind::Paren(ref subpattern) => { - visitor.visit_pat(subpattern) - } + PatKind::Box(ref subpattern) + | PatKind::Ref(ref subpattern, _) + | PatKind::Paren(ref subpattern) => visitor.visit_pat(subpattern), PatKind::Ident(_, ident, ref optional_subpattern) => { visitor.visit_ident(ident); walk_list!(visitor, visit_pat, optional_subpattern); @@ -469,10 +495,8 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) { visitor.visit_expr(lower_bound); visitor.visit_expr(upper_bound); } - PatKind::Wild | PatKind::Rest => {}, - PatKind::Tuple(ref elems) - | PatKind::Slice(ref elems) - | PatKind::Or(ref elems) => { + PatKind::Wild | PatKind::Rest => {} + PatKind::Tuple(ref elems) | PatKind::Slice(ref elems) | PatKind::Or(ref elems) => { walk_list!(visitor, visit_pat, elems); } PatKind::Mac(ref mac) => visitor.visit_mac(mac), @@ -525,23 +549,23 @@ pub fn walk_generics<'a, V: Visitor<'a>>(visitor: &mut V, generics: &'a Generics pub fn walk_where_predicate<'a, V: Visitor<'a>>(visitor: &mut V, predicate: &'a WherePredicate) { match *predicate { - WherePredicate::BoundPredicate(WhereBoundPredicate{ref bounded_ty, - ref bounds, - ref bound_generic_params, - ..}) => { + WherePredicate::BoundPredicate(WhereBoundPredicate { + ref bounded_ty, + ref bounds, + ref bound_generic_params, + .. + }) => { visitor.visit_ty(bounded_ty); walk_list!(visitor, visit_param_bound, bounds); walk_list!(visitor, visit_generic_param, bound_generic_params); } - WherePredicate::RegionPredicate(WhereRegionPredicate{ref lifetime, - ref bounds, - ..}) => { + WherePredicate::RegionPredicate(WhereRegionPredicate { + ref lifetime, ref bounds, .. + }) => { visitor.visit_lifetime(lifetime); walk_list!(visitor, visit_param_bound, bounds); } - WherePredicate::EqPredicate(WhereEqPredicate{ref lhs_ty, - ref rhs_ty, - ..}) => { + WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty, .. }) => { visitor.visit_ty(lhs_ty); visitor.visit_ty(rhs_ty); } @@ -562,7 +586,8 @@ pub fn walk_fn_decl<'a, V: Visitor<'a>>(visitor: &mut V, function_declaration: & } pub fn walk_fn<'a, V>(visitor: &mut V, kind: FnKind<'a>, declaration: &'a FnDecl, _span: Span) - where V: Visitor<'a>, +where + V: Visitor<'a>, { match kind { FnKind::ItemFn(_, header, _, body) => { @@ -605,8 +630,12 @@ pub fn walk_assoc_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) walk_fn_decl(visitor, &sig.decl); } AssocItemKind::Fn(ref sig, Some(ref body)) => { - visitor.visit_fn(FnKind::Method(item.ident, sig, &item.vis, body), - &sig.decl, item.span, item.id); + visitor.visit_fn( + FnKind::Method(item.ident, sig, &item.vis, body), + &sig.decl, + item.span, + item.id, + ); } AssocItemKind::TyAlias(ref bounds, ref ty) => { walk_list!(visitor, visit_param_bound, bounds); @@ -664,9 +693,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { walk_list!(visitor, visit_attribute, expression.attrs.iter()); match expression.kind { - ExprKind::Box(ref subexpression) => { - visitor.visit_expr(subexpression) - } + ExprKind::Box(ref subexpression) => visitor.visit_expr(subexpression), ExprKind::Array(ref subexpressions) => { walk_list!(visitor, visit_expr, subexpressions); } @@ -729,12 +756,8 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { visitor.visit_expr(subexpression); walk_list!(visitor, visit_arm, arms); } - ExprKind::Closure(_, _, _, ref function_declaration, ref body, _decl_span) => { - visitor.visit_fn(FnKind::Closure(body), - function_declaration, - expression.span, - expression.id) - } + ExprKind::Closure(_, _, _, ref function_declaration, ref body, _decl_span) => visitor + .visit_fn(FnKind::Closure(body), function_declaration, expression.span, expression.id), ExprKind::Block(ref block, ref opt_label) => { walk_list!(visitor, visit_label, opt_label); visitor.visit_block(block); @@ -780,9 +803,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { walk_list!(visitor, visit_expr, optional_expression); } ExprKind::Mac(ref mac) => visitor.visit_mac(mac), - ExprKind::Paren(ref subexpression) => { - visitor.visit_expr(subexpression) - } + ExprKind::Paren(ref subexpression) => visitor.visit_expr(subexpression), ExprKind::InlineAsm(ref ia) => { for &(_, ref input) in &ia.inputs { visitor.visit_expr(input) @@ -794,12 +815,8 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { ExprKind::Yield(ref optional_expression) => { walk_list!(visitor, visit_expr, optional_expression); } - ExprKind::Try(ref subexpression) => { - visitor.visit_expr(subexpression) - } - ExprKind::TryBlock(ref body) => { - visitor.visit_block(body) - } + ExprKind::Try(ref subexpression) => visitor.visit_expr(subexpression), + ExprKind::TryBlock(ref body) => visitor.visit_block(body), ExprKind::Lit(_) | ExprKind::Err => {} } |