From eedb95101b828c3c6295983ae8d29fd4145ec014 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Mon, 28 Sep 2015 14:26:26 +0300 Subject: [PATCH] Fill in some missing parts in the default AST visitor + Add helper macro for walking lists (including Options) --- src/librustc/lint/context.rs | 8 +- src/librustc/lint/mod.rs | 6 +- src/librustc_trans/save/dump_csv.rs | 10 +- src/libsyntax/ast.rs | 7 + src/libsyntax/ast_util.rs | 4 +- src/libsyntax/owned_slice.rs | 9 + src/libsyntax/visit.rs | 588 ++++++++++++---------------- 7 files changed, 275 insertions(+), 357 deletions(-) diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index ae9c3ce7e0b..f47c709e03a 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -898,12 +898,8 @@ fn visit_impl_item(&mut self, impl_item: &ast::ImplItem) { }); } - fn visit_opt_lifetime_ref(&mut self, sp: Span, lt: &Option) { - run_lints!(self, check_opt_lifetime_ref, early_passes, sp, lt); - } - - fn visit_lifetime_ref(&mut self, lt: &ast::Lifetime) { - run_lints!(self, check_lifetime_ref, early_passes, lt); + fn visit_lifetime(&mut self, lt: &ast::Lifetime) { + run_lints!(self, check_lifetime, early_passes, lt); } fn visit_lifetime_def(&mut self, lt: &ast::LifetimeDef) { diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index b30ac7033b7..50695fb0c17 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -199,11 +199,7 @@ fn check_struct_def_post(&mut self, _: &EarlyContext, fn check_struct_field(&mut self, _: &EarlyContext, _: &ast::StructField) { } fn check_variant(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { } fn check_variant_post(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { } - fn check_opt_lifetime_ref(&mut self, - _: &EarlyContext, - _: Span, - _: &Option) { } - fn check_lifetime_ref(&mut self, _: &EarlyContext, _: &ast::Lifetime) { } + fn check_lifetime(&mut self, _: &EarlyContext, _: &ast::Lifetime) { } fn check_lifetime_def(&mut self, _: &EarlyContext, _: &ast::LifetimeDef) { } fn check_explicit_self(&mut self, _: &EarlyContext, _: &ast::ExplicitSelf) { } fn check_path(&mut self, _: &EarlyContext, _: &ast::Path, _: ast::NodeId) { } diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index f25429ee904..6c53762c3ea 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -771,7 +771,7 @@ fn process_struct_lit(&mut self, } } - visit::walk_expr_opt(self, base) + walk_list!(self, visit_expr, base); } fn process_method_call(&mut self, ex: &ast::Expr, args: &Vec>) { @@ -785,7 +785,7 @@ fn process_method_call(&mut self, ex: &ast::Expr, args: &Vec>) { } // walk receiver and args - visit::walk_exprs(self, &args); + walk_list!(self, visit_expr, args); } fn process_pat(&mut self, p: &ast::Pat) { @@ -1200,7 +1200,7 @@ fn visit_arm(&mut self, arm: &ast::Arm) { for &(id, ref path, ref_kind) in &paths_to_process { self.process_path(id, path, ref_kind); } - visit::walk_expr_opt(self, &arm.guard); + walk_list!(self, visit_expr, &arm.guard); self.visit_expr(&arm.body); } @@ -1246,7 +1246,7 @@ fn visit_local(&mut self, l: &ast::Local) { } // Just walk the initialiser and type (don't want to walk the pattern again). - visit::walk_ty_opt(self, &l.ty); - visit::walk_expr_opt(self, &l.init); + walk_list!(self, visit_ty, &l.ty); + walk_list!(self, visit_expr, &l.init); } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 75a97629648..71261fa457f 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1613,6 +1613,13 @@ pub fn id(&self) -> NodeId { } } + pub fn name(&self) -> Option { + match *self { + PathListIdent { name, .. } => Some(name), + PathListMod { .. } => None, + } + } + pub fn rename(&self) -> Option { match *self { PathListIdent { rename, .. } | PathListMod { rename, .. } => rename diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index a7c496a0f7b..6ab1ad863ff 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -476,12 +476,12 @@ fn visit_impl_item(&mut self, ii: &ast::ImplItem) { visit::walk_impl_item(self, ii); } - fn visit_lifetime_ref(&mut self, lifetime: &Lifetime) { + fn visit_lifetime(&mut self, lifetime: &Lifetime) { self.operation.visit_id(lifetime.id); } fn visit_lifetime_def(&mut self, def: &LifetimeDef) { - self.visit_lifetime_ref(&def.lifetime); + self.visit_lifetime(&def.lifetime); } fn visit_trait_ref(&mut self, trait_ref: &TraitRef) { diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs index 25f1f9b8480..83369689a94 100644 --- a/src/libsyntax/owned_slice.rs +++ b/src/libsyntax/owned_slice.rs @@ -12,6 +12,7 @@ use std::fmt; use std::iter::{IntoIterator, FromIterator}; use std::ops::Deref; +use std::slice; use std::vec; use serialize::{Encodable, Decodable, Encoder, Decoder}; @@ -82,6 +83,14 @@ fn from_iter>(iter: I) -> OwnedSlice { } } +impl<'a, T> IntoIterator for &'a OwnedSlice { + type Item = &'a T; + type IntoIter = slice::Iter<'a, T>; + fn into_iter(self) -> Self::IntoIter { + self.data.into_iter() + } +} + impl Encodable for OwnedSlice { fn encode(&self, s: &mut S) -> Result<(), S::Error> { Encodable::encode(&**self, s) diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 23c02905cf7..531578c76d4 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -1,4 +1,4 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -25,10 +25,7 @@ use abi::Abi; use ast::*; -use ast; use codemap::Span; -use ptr::P; -use owned_slice::OwnedSlice; #[derive(Copy, Clone, PartialEq, Eq)] pub enum FnKind<'a> { @@ -56,7 +53,7 @@ fn visit_name(&mut self, _span: Span, _name: Name) { // Nothing to do. } fn visit_ident(&mut self, span: Span, ident: Ident) { - self.visit_name(span, ident.name); + walk_ident(self, span, ident); } fn visit_mod(&mut self, m: &'v Mod, _s: Span, _n: NodeId) { walk_mod(self, m) } fn visit_foreign_item(&mut self, i: &'v ForeignItem) { walk_foreign_item(self, i) } @@ -94,21 +91,8 @@ fn visit_enum_def(&mut self, enum_definition: &'v EnumDef, fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) { walk_variant(self, v, g) } - /// Visits an optional reference to a lifetime. The `span` is the span of some surrounding - /// reference should opt_lifetime be None. - fn visit_opt_lifetime_ref(&mut self, - _span: Span, - opt_lifetime: &'v Option) { - match *opt_lifetime { - Some(ref l) => self.visit_lifetime_ref(l), - None => () - } - } - fn visit_lifetime_bound(&mut self, lifetime: &'v Lifetime) { - walk_lifetime_bound(self, lifetime) - } - fn visit_lifetime_ref(&mut self, lifetime: &'v Lifetime) { - walk_lifetime_ref(self, lifetime) + fn visit_lifetime(&mut self, lifetime: &'v Lifetime) { + walk_lifetime(self, lifetime) } fn visit_lifetime_def(&mut self, lifetime: &'v LifetimeDef) { walk_lifetime_def(self, lifetime) @@ -124,7 +108,7 @@ fn visit_mac(&mut self, _mac: &'v Mac) { // definition in your trait impl: // visit::walk_mac(self, _mac) } - fn visit_path(&mut self, path: &'v Path, _id: ast::NodeId) { + fn visit_path(&mut self, path: &'v Path, _id: NodeId) { walk_path(self, path) } fn visit_path_list_item(&mut self, prefix: &'v Path, item: &'v PathListItem) { @@ -140,53 +124,83 @@ fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding) { walk_assoc_type_binding(self, type_binding) } fn visit_attribute(&mut self, _attr: &'v Attribute) {} + fn visit_macro_def(&mut self, macro_def: &'v MacroDef) { + walk_macro_def(self, macro_def) + } } -pub fn walk_crate<'v, V: Visitor<'v>>(visitor: &mut V, krate: &'v Crate) { - visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID); - for attr in &krate.attrs { - visitor.visit_attribute(attr); +#[macro_export] +macro_rules! walk_list { + ($visitor: ident, $method: ident, $list: expr) => { + for elem in $list { + $visitor.$method(elem) + } } } -pub fn walk_mod<'v, V: Visitor<'v>>(visitor: &mut V, module: &'v Mod) { - for item in &module.items { - visitor.visit_item(&**item) +pub fn walk_opt_name<'v, V: Visitor<'v>>(visitor: &mut V, span: Span, opt_name: Option) { + for name in opt_name { + visitor.visit_name(span, name); } } -pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local) { - visitor.visit_pat(&*local.pat); - walk_ty_opt(visitor, &local.ty); - walk_expr_opt(visitor, &local.init); +pub fn walk_opt_ident<'v, V: Visitor<'v>>(visitor: &mut V, span: Span, opt_ident: Option) { + for ident in opt_ident { + visitor.visit_ident(span, ident); + } } -pub fn walk_lifetime_def<'v, V: Visitor<'v>>(visitor: &mut V, - lifetime_def: &'v LifetimeDef) { - visitor.visit_name(lifetime_def.lifetime.span, lifetime_def.lifetime.name); - for bound in &lifetime_def.bounds { - visitor.visit_lifetime_bound(bound); - } +pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, span: Span, ident: Ident) { + visitor.visit_name(span, ident.name); } -pub fn walk_lifetime_bound<'v, V: Visitor<'v>>(visitor: &mut V, - lifetime_ref: &'v Lifetime) { - visitor.visit_lifetime_ref(lifetime_ref) +pub fn walk_crate<'v, V: Visitor<'v>>(visitor: &mut V, krate: &'v Crate) { + visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID); + walk_list!(visitor, visit_attribute, &krate.attrs); + walk_list!(visitor, visit_macro_def, &krate.exported_macros); +} + +pub fn walk_macro_def<'v, V: Visitor<'v>>(visitor: &mut V, macro_def: &'v MacroDef) { + visitor.visit_ident(macro_def.span, macro_def.ident); + walk_opt_ident(visitor, macro_def.span, macro_def.imported_from); + walk_list!(visitor, visit_attribute, ¯o_def.attrs); +} + +pub fn walk_mod<'v, V: Visitor<'v>>(visitor: &mut V, module: &'v Mod) { + walk_list!(visitor, visit_item, &module.items); +} + +pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local) { + visitor.visit_pat(&local.pat); + walk_list!(visitor, visit_ty, &local.ty); + walk_list!(visitor, visit_expr, &local.init); } -pub fn walk_lifetime_ref<'v, V: Visitor<'v>>(visitor: &mut V, - lifetime_ref: &'v Lifetime) { - visitor.visit_name(lifetime_ref.span, lifetime_ref.name) +pub fn walk_lifetime<'v, V: Visitor<'v>>(visitor: &mut V, lifetime: &'v Lifetime) { + visitor.visit_name(lifetime.span, lifetime.name); +} + +pub fn walk_lifetime_def<'v, V: Visitor<'v>>(visitor: &mut V, + lifetime_def: &'v LifetimeDef) { + visitor.visit_lifetime(&lifetime_def.lifetime); + walk_list!(visitor, visit_lifetime, &lifetime_def.bounds); } pub fn walk_explicit_self<'v, V: Visitor<'v>>(visitor: &mut V, explicit_self: &'v ExplicitSelf) { match explicit_self.node { - SelfStatic | SelfValue(_) => {}, - SelfRegion(ref lifetime, _, _) => { - visitor.visit_opt_lifetime_ref(explicit_self.span, lifetime) + SelfStatic => {}, + SelfValue(ident) => { + visitor.visit_ident(explicit_self.span, ident) + } + SelfRegion(ref opt_lifetime, _, ident) => { + visitor.visit_ident(explicit_self.span, ident); + walk_list!(visitor, visit_lifetime, opt_lifetime); + } + SelfExplicit(ref typ, ident) => { + visitor.visit_ident(explicit_self.span, ident); + visitor.visit_ty(typ) } - SelfExplicit(ref typ, _) => visitor.visit_ty(&**typ), } } @@ -195,7 +209,7 @@ pub fn walk_poly_trait_ref<'v, V>(visitor: &mut V, _modifier: &'v TraitBoundModifier) where V: Visitor<'v> { - walk_lifetime_decls_helper(visitor, &trait_ref.bound_lifetimes); + walk_list!(visitor, visit_lifetime_def, &trait_ref.bound_lifetimes); visitor.visit_trait_ref(&trait_ref.trait_ref); } @@ -209,10 +223,13 @@ pub fn walk_trait_ref<'v,V>(visitor: &mut V, pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { visitor.visit_ident(item.span, item.ident); match item.node { - ItemExternCrate(..) => {} + ItemExternCrate(opt_name) => { + walk_opt_name(visitor, item.span, opt_name) + } ItemUse(ref vp) => { match vp.node { - ViewPathSimple(_ident, ref path) => { + ViewPathSimple(ident, ref path) => { + visitor.visit_ident(vp.span, ident); visitor.visit_path(path, item.id); } ViewPathGlob(ref path) => { @@ -231,14 +248,14 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStatic(ref typ, _, ref expr) | ItemConst(ref typ, ref expr) => { - visitor.visit_ty(&**typ); - visitor.visit_expr(&**expr); + visitor.visit_ty(typ); + visitor.visit_expr(expr); } ItemFn(ref declaration, unsafety, constness, abi, ref generics, ref body) => { visitor.visit_fn(FnKind::ItemFn(item.ident, generics, unsafety, constness, abi, item.vis), - &**declaration, - &**body, + declaration, + body, item.span, item.id) } @@ -246,12 +263,10 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { visitor.visit_mod(module, item.span, item.id) } ItemForeignMod(ref foreign_module) => { - for foreign_item in &foreign_module.items { - visitor.visit_foreign_item(&**foreign_item) - } + walk_list!(visitor, visit_foreign_item, &foreign_module.items); } ItemTy(ref typ, ref type_parameters) => { - visitor.visit_ty(&**typ); + visitor.visit_ty(typ); visitor.visit_generics(type_parameters) } ItemEnum(ref enum_definition, ref type_parameters) => { @@ -263,45 +278,36 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemImpl(_, _, ref type_parameters, - ref trait_reference, + ref opt_trait_reference, ref typ, ref impl_items) => { visitor.visit_generics(type_parameters); - match *trait_reference { - Some(ref trait_reference) => visitor.visit_trait_ref(trait_reference), - None => () - } - visitor.visit_ty(&**typ); - for impl_item in impl_items { - visitor.visit_impl_item(impl_item); - } + walk_list!(visitor, visit_trait_ref, opt_trait_reference); + visitor.visit_ty(typ); + walk_list!(visitor, visit_impl_item, impl_items); } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(&**struct_definition, + visitor.visit_struct_def(struct_definition, item.ident, generics, item.id) } ItemTrait(_, ref generics, ref bounds, ref methods) => { visitor.visit_generics(generics); - walk_ty_param_bounds_helper(visitor, bounds); - for method in methods { - visitor.visit_trait_item(method) - } + walk_list!(visitor, visit_ty_param_bound, bounds); + walk_list!(visitor, visit_trait_item, methods); } ItemMac(ref mac) => visitor.visit_mac(mac), } - for attr in &item.attrs { - visitor.visit_attribute(attr); - } + walk_list!(visitor, visit_attribute, &item.attrs); } pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V, enum_definition: &'v EnumDef, generics: &'v Generics) { for variant in &enum_definition.variants { - visitor.visit_variant(&**variant, generics); + visitor.visit_variant(variant, generics); } } @@ -313,79 +319,58 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, match variant.node.kind { TupleVariantKind(ref variant_arguments) => { for variant_argument in variant_arguments { - visitor.visit_ty(&*variant_argument.ty) + visitor.visit_ty(&variant_argument.ty) } } StructVariantKind(ref struct_definition) => { - visitor.visit_struct_def(&**struct_definition, + visitor.visit_struct_def(struct_definition, variant.node.name, generics, variant.node.id) } } - match variant.node.disr_expr { - Some(ref expr) => visitor.visit_expr(&**expr), - None => () - } - for attr in &variant.node.attrs { - visitor.visit_attribute(attr); - } -} - -pub fn skip_ty<'v, V: Visitor<'v>>(_: &mut V, _: &'v Ty) { - // Empty! -} - -pub fn walk_ty_opt<'v, V: Visitor<'v>>(visitor: &mut V, optional_type: &'v Option>) { - match *optional_type { - Some(ref ty) => visitor.visit_ty(&**ty), - None => () - } + walk_list!(visitor, visit_expr, &variant.node.disr_expr); + walk_list!(visitor, visit_attribute, &variant.node.attrs); } pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) { match typ.node { TyVec(ref ty) | TyParen(ref ty) => { - visitor.visit_ty(&**ty) + visitor.visit_ty(ty) } TyPtr(ref mutable_type) => { - visitor.visit_ty(&*mutable_type.ty) + visitor.visit_ty(&mutable_type.ty) } - TyRptr(ref lifetime, ref mutable_type) => { - visitor.visit_opt_lifetime_ref(typ.span, lifetime); - visitor.visit_ty(&*mutable_type.ty) + TyRptr(ref opt_lifetime, ref mutable_type) => { + walk_list!(visitor, visit_lifetime, opt_lifetime); + visitor.visit_ty(&mutable_type.ty) } TyTup(ref tuple_element_types) => { - for tuple_element_type in tuple_element_types { - visitor.visit_ty(&**tuple_element_type) - } + walk_list!(visitor, visit_ty, tuple_element_types); } TyBareFn(ref function_declaration) => { - for argument in &function_declaration.decl.inputs { - visitor.visit_ty(&*argument.ty) - } - walk_fn_ret_ty(visitor, &function_declaration.decl.output); - walk_lifetime_decls_helper(visitor, &function_declaration.lifetimes); + walk_fn_decl(visitor, &function_declaration.decl); + walk_list!(visitor, visit_lifetime_def, &function_declaration.lifetimes); } TyPath(ref maybe_qself, ref path) => { - if let Some(ref qself) = *maybe_qself { + for qself in maybe_qself { visitor.visit_ty(&qself.ty); } visitor.visit_path(path, typ.id); } TyObjectSum(ref ty, ref bounds) => { - visitor.visit_ty(&**ty); - walk_ty_param_bounds_helper(visitor, bounds); + visitor.visit_ty(ty); + walk_list!(visitor, visit_ty_param_bound, bounds); } TyFixedLengthVec(ref ty, ref expression) => { - visitor.visit_ty(&**ty); - visitor.visit_expr(&**expression) + visitor.visit_ty(ty); + visitor.visit_expr(expression) } TyPolyTraitRef(ref bounds) => { - walk_ty_param_bounds_helper(visitor, bounds) + walk_list!(visitor, visit_ty_param_bound, bounds); } TyTypeof(ref expression) => { - visitor.visit_expr(&**expression) + visitor.visit_expr(expression) } TyInfer => {} TyMac(ref mac) => { @@ -394,13 +379,6 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) { } } -pub fn walk_lifetime_decls_helper<'v, V: Visitor<'v>>(visitor: &mut V, - lifetimes: &'v Vec) { - for l in lifetimes { - visitor.visit_lifetime_def(l); - } -} - pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) { for segment in &path.segments { visitor.visit_path_segment(path.span, segment); @@ -413,9 +391,8 @@ pub fn walk_path_list_item<'v, V: Visitor<'v>>(visitor: &mut V, prefix: &'v Path visitor.visit_path_segment(prefix.span, segment); } - if let PathListIdent { name, .. } = item.node { - visitor.visit_ident(item.span, name); - } + walk_opt_ident(visitor, item.span, item.node.name()); + walk_opt_ident(visitor, item.span, item.node.rename()); } pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V, @@ -429,24 +406,14 @@ pub fn walk_path_parameters<'v, V: Visitor<'v>>(visitor: &mut V, _path_span: Span, path_parameters: &'v PathParameters) { match *path_parameters { - ast::AngleBracketedParameters(ref data) => { - for typ in data.types.iter() { - visitor.visit_ty(&**typ); - } - for lifetime in &data.lifetimes { - visitor.visit_lifetime_ref(lifetime); - } - for binding in data.bindings.iter() { - visitor.visit_assoc_type_binding(&**binding); - } + AngleBracketedParameters(ref data) => { + walk_list!(visitor, visit_ty, &data.types); + walk_list!(visitor, visit_lifetime, &data.lifetimes); + walk_list!(visitor, visit_assoc_type_binding, &data.bindings); } - ast::ParenthesizedParameters(ref data) => { - for typ in &data.inputs { - visitor.visit_ty(&**typ); - } - if let Some(ref typ) = data.output { - visitor.visit_ty(&**typ); - } + ParenthesizedParameters(ref data) => { + walk_list!(visitor, visit_ty, &data.inputs); + walk_list!(visitor, visit_ty, &data.output); } } } @@ -454,17 +421,15 @@ pub fn walk_path_parameters<'v, V: Visitor<'v>>(visitor: &mut V, pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(visitor: &mut V, type_binding: &'v TypeBinding) { visitor.visit_ident(type_binding.span, type_binding.ident); - visitor.visit_ty(&*type_binding.ty); + visitor.visit_ty(&type_binding.ty); } pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) { match pattern.node { - PatEnum(ref path, ref children) => { + PatEnum(ref path, ref opt_children) => { visitor.visit_path(path, pattern.id); - if let Some(ref children) = *children { - for child in children { - visitor.visit_pat(&*child) - } + for children in opt_children { + walk_list!(visitor, visit_pat, children); } } PatQPath(ref qself, ref path) => { @@ -474,41 +439,31 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) { PatStruct(ref path, ref fields, _) => { visitor.visit_path(path, pattern.id); for field in fields { - visitor.visit_pat(&*field.node.pat) + visitor.visit_ident(field.span, field.node.ident); + visitor.visit_pat(&field.node.pat) } } PatTup(ref tuple_elements) => { - for tuple_element in tuple_elements { - visitor.visit_pat(&**tuple_element) - } + walk_list!(visitor, visit_pat, tuple_elements); } PatBox(ref subpattern) | PatRegion(ref subpattern, _) => { - visitor.visit_pat(&**subpattern) + visitor.visit_pat(subpattern) } PatIdent(_, ref pth1, ref optional_subpattern) => { visitor.visit_ident(pth1.span, pth1.node); - match *optional_subpattern { - None => {} - Some(ref subpattern) => visitor.visit_pat(&**subpattern), - } + walk_list!(visitor, visit_pat, optional_subpattern); } - PatLit(ref expression) => visitor.visit_expr(&**expression), + PatLit(ref expression) => visitor.visit_expr(expression), PatRange(ref lower_bound, ref upper_bound) => { - visitor.visit_expr(&**lower_bound); - visitor.visit_expr(&**upper_bound) + visitor.visit_expr(lower_bound); + visitor.visit_expr(upper_bound) } PatWild(_) => (), - PatVec(ref prepattern, ref slice_pattern, ref postpatterns) => { - for prepattern in prepattern { - visitor.visit_pat(&**prepattern) - } - if let Some(ref slice_pattern) = *slice_pattern { - visitor.visit_pat(&**slice_pattern) - } - for postpattern in postpatterns { - visitor.visit_pat(&**postpattern) - } + PatVec(ref prepatterns, ref slice_pattern, ref postpatterns) => { + walk_list!(visitor, visit_pat, prepatterns); + walk_list!(visitor, visit_pat, slice_pattern); + walk_list!(visitor, visit_pat, postpatterns); } PatMac(ref mac) => visitor.visit_mac(mac), } @@ -520,22 +475,13 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, match foreign_item.node { ForeignItemFn(ref function_declaration, ref generics) => { - walk_fn_decl(visitor, &**function_declaration); + walk_fn_decl(visitor, function_declaration); visitor.visit_generics(generics) } - ForeignItemStatic(ref typ, _) => visitor.visit_ty(&**typ), - } - - for attr in &foreign_item.attrs { - visitor.visit_attribute(attr); + ForeignItemStatic(ref typ, _) => visitor.visit_ty(typ), } -} -pub fn walk_ty_param_bounds_helper<'v, V: Visitor<'v>>(visitor: &mut V, - bounds: &'v OwnedSlice) { - for bound in bounds.iter() { - visitor.visit_ty_param_bound(bound) - } + walk_list!(visitor, visit_attribute, &foreign_item.attrs); } pub fn walk_ty_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, @@ -545,58 +491,53 @@ pub fn walk_ty_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, visitor.visit_poly_trait_ref(typ, modifier); } RegionTyParamBound(ref lifetime) => { - visitor.visit_lifetime_bound(lifetime); + visitor.visit_lifetime(lifetime); } } } pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics) { - for param in generics.ty_params.iter() { + for param in &generics.ty_params { visitor.visit_ident(param.span, param.ident); - walk_ty_param_bounds_helper(visitor, ¶m.bounds); - walk_ty_opt(visitor, ¶m.default); + walk_list!(visitor, visit_ty_param_bound, ¶m.bounds); + walk_list!(visitor, visit_ty, ¶m.default); } - walk_lifetime_decls_helper(visitor, &generics.lifetimes); + walk_list!(visitor, visit_lifetime_def, &generics.lifetimes); for predicate in &generics.where_clause.predicates { match predicate { - &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bounded_ty, + &WherePredicate::BoundPredicate(WhereBoundPredicate{ref bounded_ty, ref bounds, + ref bound_lifetimes, ..}) => { - visitor.visit_ty(&**bounded_ty); - walk_ty_param_bounds_helper(visitor, bounds); + visitor.visit_ty(bounded_ty); + walk_list!(visitor, visit_ty_param_bound, bounds); + walk_list!(visitor, visit_lifetime_def, bound_lifetimes); } - &ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime, + &WherePredicate::RegionPredicate(WhereRegionPredicate{ref lifetime, ref bounds, ..}) => { - visitor.visit_lifetime_ref(lifetime); - - for bound in bounds { - visitor.visit_lifetime_ref(bound); - } + visitor.visit_lifetime(lifetime); + walk_list!(visitor, visit_lifetime, bounds); } - &ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{id, + &WherePredicate::EqPredicate(WhereEqPredicate{id, ref path, ref ty, ..}) => { visitor.visit_path(path, id); - visitor.visit_ty(&**ty); + visitor.visit_ty(ty); } } } } -pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FunctionRetTy) { - if let Return(ref output_ty) = *ret_ty { - visitor.visit_ty(&**output_ty) - } -} - pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl) { for argument in &function_declaration.inputs { - visitor.visit_pat(&*argument.pat); - visitor.visit_ty(&*argument.ty) + visitor.visit_pat(&argument.pat); + visitor.visit_ty(&argument.ty) + } + if let Return(ref output_ty) = function_declaration.output { + visitor.visit_ty(output_ty) } - walk_fn_ret_ty(visitor, &function_declaration.output) } pub fn walk_fn<'v, V: Visitor<'v>>(visitor: &mut V, @@ -614,7 +555,7 @@ pub fn walk_fn<'v, V: Visitor<'v>>(visitor: &mut V, visitor.visit_generics(&sig.generics); visitor.visit_explicit_self(&sig.explicit_self); } - FnKind::Closure(..) => {} + FnKind::Closure => {} } visitor.visit_block(function_body) @@ -622,15 +563,11 @@ pub fn walk_fn<'v, V: Visitor<'v>>(visitor: &mut V, pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v TraitItem) { visitor.visit_ident(trait_item.span, trait_item.ident); - for attr in &trait_item.attrs { - visitor.visit_attribute(attr); - } + walk_list!(visitor, visit_attribute, &trait_item.attrs); match trait_item.node { ConstTraitItem(ref ty, ref default) => { visitor.visit_ty(ty); - if let Some(ref expr) = *default { - visitor.visit_expr(expr); - } + walk_list!(visitor, visit_expr, default); } MethodTraitItem(ref sig, None) => { visitor.visit_explicit_self(&sig.explicit_self); @@ -642,17 +579,15 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai body, trait_item.span, trait_item.id); } TypeTraitItem(ref bounds, ref default) => { - walk_ty_param_bounds_helper(visitor, bounds); - walk_ty_opt(visitor, default); + walk_list!(visitor, visit_ty_param_bound, bounds); + walk_list!(visitor, visit_ty, default); } } } pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplItem) { visitor.visit_ident(impl_item.span, impl_item.ident); - for attr in &impl_item.attrs { - visitor.visit_attribute(attr); - } + walk_list!(visitor, visit_attribute, &impl_item.attrs); match impl_item.node { ConstImplItem(ref ty, ref expr) => { visitor.visit_ty(ty); @@ -673,59 +608,35 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &'v StructDef) { - for field in &struct_definition.fields { - visitor.visit_struct_field(field) - } + walk_list!(visitor, visit_struct_field, &struct_definition.fields); } pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, struct_field: &'v StructField) { - if let NamedField(name, _) = struct_field.node.kind { - visitor.visit_ident(struct_field.span, name); - } - - visitor.visit_ty(&*struct_field.node.ty); - - for attr in &struct_field.node.attrs { - visitor.visit_attribute(attr); - } + walk_opt_ident(visitor, struct_field.span, struct_field.node.ident()); + visitor.visit_ty(&struct_field.node.ty); + walk_list!(visitor, visit_attribute, &struct_field.node.attrs); } pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block) { - for statement in &block.stmts { - visitor.visit_stmt(&**statement) - } - walk_expr_opt(visitor, &block.expr) + walk_list!(visitor, visit_stmt, &block.stmts); + walk_list!(visitor, visit_expr, &block.expr); } pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt) { match statement.node { - StmtDecl(ref declaration, _) => visitor.visit_decl(&**declaration), + StmtDecl(ref declaration, _) => visitor.visit_decl(declaration), StmtExpr(ref expression, _) | StmtSemi(ref expression, _) => { - visitor.visit_expr(&**expression) + visitor.visit_expr(expression) } - StmtMac(ref mac, _) => visitor.visit_mac(&**mac), + StmtMac(ref mac, _) => visitor.visit_mac(mac), } } pub fn walk_decl<'v, V: Visitor<'v>>(visitor: &mut V, declaration: &'v Decl) { match declaration.node { - DeclLocal(ref local) => visitor.visit_local(&**local), - DeclItem(ref item) => visitor.visit_item(&**item), - } -} - -pub fn walk_expr_opt<'v, V: Visitor<'v>>(visitor: &mut V, - optional_expression: &'v Option>) { - match *optional_expression { - None => {} - Some(ref expression) => visitor.visit_expr(&**expression), - } -} - -pub fn walk_exprs<'v, V: Visitor<'v>>(visitor: &mut V, expressions: &'v [P]) { - for expression in expressions { - visitor.visit_expr(&**expression) + DeclLocal(ref local) => visitor.visit_local(local), + DeclItem(ref item) => visitor.visit_item(item), } } @@ -736,139 +647,142 @@ pub fn walk_mac<'v, V: Visitor<'v>>(_: &mut V, _: &'v Mac) { pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { match expression.node { ExprBox(ref subexpression) => { - visitor.visit_expr(&**subexpression) + visitor.visit_expr(subexpression) } ExprInPlace(ref place, ref subexpression) => { - visitor.visit_expr(&**place); - visitor.visit_expr(&**subexpression) + visitor.visit_expr(place); + visitor.visit_expr(subexpression) } ExprVec(ref subexpressions) => { - walk_exprs(visitor, subexpressions) + walk_list!(visitor, visit_expr, subexpressions); } ExprRepeat(ref element, ref count) => { - visitor.visit_expr(&**element); - visitor.visit_expr(&**count) + visitor.visit_expr(element); + visitor.visit_expr(count) } ExprStruct(ref path, ref fields, ref optional_base) => { visitor.visit_path(path, expression.id); for field in fields { - visitor.visit_expr(&*field.expr) + visitor.visit_ident(field.ident.span, field.ident.node); + visitor.visit_expr(&field.expr) } - walk_expr_opt(visitor, optional_base) + walk_list!(visitor, visit_expr, optional_base); } ExprTup(ref subexpressions) => { - for subexpression in subexpressions { - visitor.visit_expr(&**subexpression) - } + walk_list!(visitor, visit_expr, subexpressions); } ExprCall(ref callee_expression, ref arguments) => { - for argument in arguments { - visitor.visit_expr(&**argument) - } - visitor.visit_expr(&**callee_expression) + walk_list!(visitor, visit_expr, arguments); + visitor.visit_expr(callee_expression) } - ExprMethodCall(_, ref types, ref arguments) => { - walk_exprs(visitor, arguments); - for typ in types { - visitor.visit_ty(&**typ) - } + ExprMethodCall(ref ident, ref types, ref arguments) => { + visitor.visit_ident(ident.span, ident.node); + walk_list!(visitor, visit_expr, arguments); + walk_list!(visitor, visit_ty, types); } ExprBinary(_, ref left_expression, ref right_expression) => { - visitor.visit_expr(&**left_expression); - visitor.visit_expr(&**right_expression) + visitor.visit_expr(left_expression); + visitor.visit_expr(right_expression) } ExprAddrOf(_, ref subexpression) | ExprUnary(_, ref subexpression) => { - visitor.visit_expr(&**subexpression) + visitor.visit_expr(subexpression) } ExprLit(_) => {} ExprCast(ref subexpression, ref typ) => { - visitor.visit_expr(&**subexpression); - visitor.visit_ty(&**typ) + visitor.visit_expr(subexpression); + visitor.visit_ty(typ) } ExprIf(ref head_expression, ref if_block, ref optional_else) => { - visitor.visit_expr(&**head_expression); - visitor.visit_block(&**if_block); - walk_expr_opt(visitor, optional_else) + visitor.visit_expr(head_expression); + visitor.visit_block(if_block); + walk_list!(visitor, visit_expr, optional_else); } - ExprWhile(ref subexpression, ref block, _) => { - visitor.visit_expr(&**subexpression); - visitor.visit_block(&**block) + ExprWhile(ref subexpression, ref block, opt_ident) => { + visitor.visit_expr(subexpression); + visitor.visit_block(block); + walk_opt_ident(visitor, expression.span, opt_ident) } ExprIfLet(ref pattern, ref subexpression, ref if_block, ref optional_else) => { - visitor.visit_pat(&**pattern); - visitor.visit_expr(&**subexpression); - visitor.visit_block(&**if_block); - walk_expr_opt(visitor, optional_else); - } - ExprWhileLet(ref pattern, ref subexpression, ref block, _) => { - visitor.visit_pat(&**pattern); - visitor.visit_expr(&**subexpression); - visitor.visit_block(&**block); - } - ExprForLoop(ref pattern, ref subexpression, ref block, _) => { - visitor.visit_pat(&**pattern); - visitor.visit_expr(&**subexpression); - visitor.visit_block(&**block) - } - ExprLoop(ref block, _) => visitor.visit_block(&**block), + visitor.visit_pat(pattern); + visitor.visit_expr(subexpression); + visitor.visit_block(if_block); + walk_list!(visitor, visit_expr, optional_else); + } + ExprWhileLet(ref pattern, ref subexpression, ref block, opt_ident) => { + visitor.visit_pat(pattern); + visitor.visit_expr(subexpression); + visitor.visit_block(block); + walk_opt_ident(visitor, expression.span, opt_ident) + } + ExprForLoop(ref pattern, ref subexpression, ref block, opt_ident) => { + visitor.visit_pat(pattern); + visitor.visit_expr(subexpression); + visitor.visit_block(block); + walk_opt_ident(visitor, expression.span, opt_ident) + } + ExprLoop(ref block, opt_ident) => { + visitor.visit_block(block); + walk_opt_ident(visitor, expression.span, opt_ident) + } ExprMatch(ref subexpression, ref arms, _) => { - visitor.visit_expr(&**subexpression); - for arm in arms { - visitor.visit_arm(arm) - } + visitor.visit_expr(subexpression); + walk_list!(visitor, visit_arm, arms); } ExprClosure(_, ref function_declaration, ref body) => { visitor.visit_fn(FnKind::Closure, - &**function_declaration, - &**body, + function_declaration, + body, expression.span, expression.id) } - ExprBlock(ref block) => visitor.visit_block(&**block), + ExprBlock(ref block) => visitor.visit_block(block), ExprAssign(ref left_hand_expression, ref right_hand_expression) => { - visitor.visit_expr(&**right_hand_expression); - visitor.visit_expr(&**left_hand_expression) + visitor.visit_expr(right_hand_expression); + visitor.visit_expr(left_hand_expression) } ExprAssignOp(_, ref left_expression, ref right_expression) => { - visitor.visit_expr(&**right_expression); - visitor.visit_expr(&**left_expression) + visitor.visit_expr(right_expression); + visitor.visit_expr(left_expression) } - ExprField(ref subexpression, _) => { - visitor.visit_expr(&**subexpression); + ExprField(ref subexpression, ref ident) => { + visitor.visit_expr(subexpression); + visitor.visit_ident(ident.span, ident.node); } ExprTupField(ref subexpression, _) => { - visitor.visit_expr(&**subexpression); + visitor.visit_expr(subexpression); } ExprIndex(ref main_expression, ref index_expression) => { - visitor.visit_expr(&**main_expression); - visitor.visit_expr(&**index_expression) + visitor.visit_expr(main_expression); + visitor.visit_expr(index_expression) } ExprRange(ref start, ref end) => { - walk_expr_opt(visitor, start); - walk_expr_opt(visitor, end) + walk_list!(visitor, visit_expr, start); + walk_list!(visitor, visit_expr, end); } ExprPath(ref maybe_qself, ref path) => { - if let Some(ref qself) = *maybe_qself { + for qself in maybe_qself { visitor.visit_ty(&qself.ty); } visitor.visit_path(path, expression.id) } - ExprBreak(_) | ExprAgain(_) => {} + ExprBreak(ref opt_sp_ident) | ExprAgain(ref opt_sp_ident) => { + for sp_ident in opt_sp_ident { + visitor.visit_ident(sp_ident.span, sp_ident.node); + } + } ExprRet(ref optional_expression) => { - walk_expr_opt(visitor, optional_expression) + walk_list!(visitor, visit_expr, optional_expression); } ExprMac(ref mac) => visitor.visit_mac(mac), ExprParen(ref subexpression) => { - visitor.visit_expr(&**subexpression) + visitor.visit_expr(subexpression) } ExprInlineAsm(ref ia) => { - for input in &ia.inputs { - let (_, ref input) = *input; - visitor.visit_expr(&**input) + for &(_, ref input) in &ia.inputs { + visitor.visit_expr(&input) } - for output in &ia.outputs { - let (_, ref output, _) = *output; - visitor.visit_expr(&**output) + for &(_, ref output, _) in &ia.outputs { + visitor.visit_expr(&output) } } } @@ -877,12 +791,8 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) { } pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm) { - for pattern in &arm.pats { - visitor.visit_pat(&**pattern) - } - walk_expr_opt(visitor, &arm.guard); - visitor.visit_expr(&*arm.body); - for attr in &arm.attrs { - visitor.visit_attribute(attr); - } + walk_list!(visitor, visit_pat, &arm.pats); + walk_list!(visitor, visit_expr, &arm.guard); + visitor.visit_expr(&arm.body); + walk_list!(visitor, visit_attribute, &arm.attrs); } -- 2.44.0