Remove the type parameter from syntax::visit::Visitor

jseyfried · jseyfried · commit 0644aba0b3f5 · 2016-06-14T07:40:32.000Z
diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs
@@ -95,7 +95,7 @@ impl<'a> CheckAttrVisitor<'a> {
     }
 }
 
-impl<'a, 'v> Visitor<'v> for CheckAttrVisitor<'a> {
+impl<'a> Visitor for CheckAttrVisitor<'a> {
     fn visit_item(&mut self, item: &ast::Item) {
         let target = Target::from_item(item);
         for attr in &item.attrs {
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -138,8 +138,8 @@ impl<'a> LoweringContext<'a> {
             lctx: &'lcx mut LoweringContext<'interner>,
         }
 
-        impl<'lcx, 'interner> Visitor<'lcx> for ItemLowerer<'lcx, 'interner> {
-            fn visit_item(&mut self, item: &'lcx Item) {
+        impl<'lcx, 'interner> Visitor for ItemLowerer<'lcx, 'interner> {
+            fn visit_item(&mut self, item: &Item) {
                 self.items.insert(item.id, self.lctx.lower_item(item));
                 visit::walk_item(self, item);
             }
diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs
@@ -98,7 +98,7 @@ impl<'ast> DefCollector<'ast> {
         self.parent_def = parent;
     }
 
-    fn visit_ast_const_integer(&mut self, expr: &'ast Expr) {
+    fn visit_ast_const_integer(&mut self, expr: &Expr) {
         // Find the node which will be used after lowering.
         if let ExprKind::Paren(ref inner) = expr.node {
             return self.visit_ast_const_integer(inner);
@@ -124,8 +124,8 @@ impl<'ast> DefCollector<'ast> {
     }
 }
 
-impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
-    fn visit_item(&mut self, i: &'ast Item) {
+impl<'ast> visit::Visitor for DefCollector<'ast> {
+    fn visit_item(&mut self, i: &Item) {
         debug!("visit_item: {:?}", i);
 
         // Pick the def data. This need not be unique, but the more
@@ -183,23 +183,23 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
         });
     }
 
-    fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) {
+    fn visit_foreign_item(&mut self, foreign_item: &ForeignItem) {
         let def = self.create_def(foreign_item.id, DefPathData::ValueNs(foreign_item.ident.name));
 
         self.with_parent(def, |this| {
             visit::walk_foreign_item(this, foreign_item);
         });
     }
 
-    fn visit_generics(&mut self, generics: &'ast Generics) {
+    fn visit_generics(&mut self, generics: &Generics) {
         for ty_param in generics.ty_params.iter() {
             self.create_def(ty_param.id, DefPathData::TypeParam(ty_param.ident.name));
         }
 
         visit::walk_generics(self, generics);
     }
 
-    fn visit_trait_item(&mut self, ti: &'ast TraitItem) {
+    fn visit_trait_item(&mut self, ti: &TraitItem) {
         let def_data = match ti.node {
             TraitItemKind::Method(..) | TraitItemKind::Const(..) =>
                 DefPathData::ValueNs(ti.ident.name),
@@ -216,7 +216,7 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
         });
     }
 
-    fn visit_impl_item(&mut self, ii: &'ast ImplItem) {
+    fn visit_impl_item(&mut self, ii: &ImplItem) {
         let def_data = match ii.node {
             ImplItemKind::Method(..) | ImplItemKind::Const(..) =>
                 DefPathData::ValueNs(ii.ident.name),
@@ -234,7 +234,7 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
         });
     }
 
-    fn visit_pat(&mut self, pat: &'ast Pat) {
+    fn visit_pat(&mut self, pat: &Pat) {
         let parent_def = self.parent_def;
 
         if let PatKind::Ident(_, id, _) = pat.node {
@@ -246,7 +246,7 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
         self.parent_def = parent_def;
     }
 
-    fn visit_expr(&mut self, expr: &'ast Expr) {
+    fn visit_expr(&mut self, expr: &Expr) {
         let parent_def = self.parent_def;
 
         if let ExprKind::Repeat(_, ref count) = expr.node {
@@ -262,18 +262,18 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
         self.parent_def = parent_def;
     }
 
-    fn visit_ty(&mut self, ty: &'ast Ty) {
+    fn visit_ty(&mut self, ty: &Ty) {
         if let TyKind::FixedLengthVec(_, ref length) = ty.node {
             self.visit_ast_const_integer(length);
         }
         visit::walk_ty(self, ty);
     }
 
-    fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) {
+    fn visit_lifetime_def(&mut self, def: &LifetimeDef) {
         self.create_def(def.lifetime.id, DefPathData::LifetimeDef(def.lifetime.name));
     }
 
-    fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) {
+    fn visit_macro_def(&mut self, macro_def: &MacroDef) {
         self.create_def(macro_def.id, DefPathData::MacroDef(macro_def.ident.name));
     }
 }
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -905,7 +905,7 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
     }
 }
 
-impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {
+impl<'a> ast_visit::Visitor for EarlyContext<'a> {
     fn visit_item(&mut self, it: &ast::Item) {
         self.with_lint_attrs(&it.attrs, |cx| {
             run_lints!(cx, check_item, early_passes, it);
@@ -939,8 +939,8 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {
         ast_visit::walk_stmt(self, s);
     }
 
-    fn visit_fn(&mut self, fk: ast_visit::FnKind<'v>, decl: &'v ast::FnDecl,
-                body: &'v ast::Block, span: Span, id: ast::NodeId) {
+    fn visit_fn(&mut self, fk: ast_visit::FnKind, decl: &ast::FnDecl,
+                body: &ast::Block, span: Span, id: ast::NodeId) {
         run_lints!(self, check_fn, early_passes, fk, decl, body, span, id);
         ast_visit::walk_fn(self, fk, decl, body, span);
         run_lints!(self, check_fn_post, early_passes, fk, decl, body, span, id);
diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs
@@ -58,8 +58,8 @@ pub struct CrateReader<'a> {
     local_crate_name: String,
 }
 
-impl<'a, 'ast> visit::Visitor<'ast> for LocalCrateReader<'a> {
-    fn visit_item(&mut self, a: &'ast ast::Item) {
+impl<'a> visit::Visitor for LocalCrateReader<'a> {
+    fn visit_item(&mut self, a: &ast::Item) {
         self.process_item(a);
         visit::walk_item(self, a);
     }
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
@@ -57,7 +57,7 @@ impl<'a> AstValidator<'a> {
     }
 }
 
-impl<'a, 'v> Visitor<'v> for AstValidator<'a> {
+impl<'a> Visitor for AstValidator<'a> {
     fn visit_lifetime(&mut self, lt: &Lifetime) {
         if lt.name.as_str() == "'_" {
             self.session.add_lint(
diff --git a/src/librustc_passes/no_asm.rs b/src/librustc_passes/no_asm.rs
@@ -29,7 +29,7 @@ struct CheckNoAsm<'a> {
     sess: &'a Session,
 }
 
-impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {
+impl<'a> Visitor for CheckNoAsm<'a> {
     fn visit_expr(&mut self, e: &ast::Expr) {
         match e.node {
             ast::ExprKind::InlineAsm(_) => span_err!(self.sess, e.span, E0472,
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
@@ -503,7 +503,7 @@ struct BuildReducedGraphVisitor<'a, 'b: 'a> {
     parent: Module<'b>,
 }
 
-impl<'a, 'b, 'v> Visitor<'v> for BuildReducedGraphVisitor<'a, 'b> {
+impl<'a, 'b> Visitor for BuildReducedGraphVisitor<'a, 'b> {
     fn visit_item(&mut self, item: &Item) {
         let old_parent = self.parent;
         self.resolver.build_reduced_graph_for_item(item, &mut self.parent);
diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs
@@ -71,7 +71,7 @@ impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
     }
 }
 
-impl<'a, 'b, 'v> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b> {
+impl<'a, 'b> Visitor for UnusedImportCheckVisitor<'a, 'b> {
     fn visit_item(&mut self, item: &ast::Item) {
         visit::walk_item(self, item);
         // Ignore is_public import statements because there's no way to be sure
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -500,7 +500,7 @@ pub enum Namespace {
     ValueNS,
 }
 
-impl<'a, 'v> Visitor<'v> for Resolver<'a> {
+impl<'a> Visitor for Resolver<'a> {
     fn visit_item(&mut self, item: &Item) {
         self.resolve_item(item);
     }
@@ -562,9 +562,9 @@ impl<'a, 'v> Visitor<'v> for Resolver<'a> {
         });
     }
     fn visit_fn(&mut self,
-                function_kind: FnKind<'v>,
-                declaration: &'v FnDecl,
-                block: &'v Block,
+                function_kind: FnKind,
+                declaration: &FnDecl,
+                block: &Block,
                 _: Span,
                 node_id: NodeId) {
         let rib_kind = match function_kind {
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -1013,7 +1013,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
     }
 }
 
-impl<'v, 'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor<'v> for DumpVisitor<'l, 'tcx, 'll, D> {
+impl<'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor for DumpVisitor<'l, 'tcx, 'll, D> {
     fn visit_item(&mut self, item: &ast::Item) {
         use syntax::ast::ItemKind::*;
         self.process_macro_use(item.span, item.id);
diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs
@@ -686,7 +686,7 @@ impl PathCollector {
     }
 }
 
-impl<'v> Visitor<'v> for PathCollector {
+impl Visitor for PathCollector {
     fn visit_pat(&mut self, p: &ast::Pat) {
         match p.node {
             PatKind::Struct(ref path, _, _) => {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -573,7 +573,7 @@ struct PatIdentFinder {
     ident_accumulator: Vec<ast::Ident>
 }
 
-impl<'v> Visitor<'v> for PatIdentFinder {
+impl Visitor for PatIdentFinder {
     fn visit_pat(&mut self, pattern: &ast::Pat) {
         match *pattern {
             ast::Pat { id: _, node: PatKind::Ident(_, ref path1, ref inner), span: _ } => {
@@ -1226,7 +1226,7 @@ mod tests {
         path_accumulator: Vec<ast::Path> ,
     }
 
-    impl<'v> Visitor<'v> for PathExprFinderContext {
+    impl Visitor for PathExprFinderContext {
         fn visit_expr(&mut self, expr: &ast::Expr) {
             if let ast::ExprKind::Path(None, ref p) = expr.node {
                 self.path_accumulator.push(p.clone());
@@ -1248,7 +1248,7 @@ mod tests {
         ident_accumulator: Vec<ast::Ident>
     }
 
-    impl<'v> Visitor<'v> for IdentFinder {
+    impl Visitor for IdentFinder {
         fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){
             self.ident_accumulator.push(id);
         }
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
@@ -849,7 +849,7 @@ macro_rules! gate_feature_post {
     }}
 }
 
-impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
+impl<'a> Visitor for PostExpansionVisitor<'a> {
     fn visit_attribute(&mut self, attr: &ast::Attribute) {
         if !self.context.cm.span_allows_unstable(attr.span) {
             self.context.check_attribute(attr, false);
@@ -1045,9 +1045,9 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
     }
 
     fn visit_fn(&mut self,
-                fn_kind: FnKind<'v>,
-                fn_decl: &'v ast::FnDecl,
-                block: &'v ast::Block,
+                fn_kind: FnKind,
+                fn_decl: &ast::FnDecl,
+                block: &ast::Block,
                 span: Span,
                 _node_id: NodeId) {
         // check for const fn declarations
@@ -1086,7 +1086,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
         visit::walk_fn(self, fn_kind, fn_decl, block, span);
     }
 
-    fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {
+    fn visit_trait_item(&mut self, ti: &ast::TraitItem) {
         match ti.node {
             ast::TraitItemKind::Const(..) => {
                 gate_feature_post!(&self, associated_consts,
@@ -1107,7 +1107,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
         visit::walk_trait_item(self, ti);
     }
 
-    fn visit_impl_item(&mut self, ii: &'v ast::ImplItem) {
+    fn visit_impl_item(&mut self, ii: &ast::ImplItem) {
         if ii.defaultness == ast::Defaultness::Default {
             gate_feature_post!(&self, specialization,
                               ii.span,
@@ -1130,7 +1130,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
         visit::walk_impl_item(self, ii);
     }
 
-    fn visit_vis(&mut self, vis: &'v ast::Visibility) {
+    fn visit_vis(&mut self, vis: &ast::Visibility) {
         let span = match *vis {
             ast::Visibility::Crate(span) => span,
             ast::Visibility::Restricted { ref path, .. } => path.span,
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -991,8 +991,8 @@ mod tests {
         struct PatIdentVisitor {
             spans: Vec<Span>
         }
-        impl<'v> ::visit::Visitor<'v> for PatIdentVisitor {
-            fn visit_pat(&mut self, p: &'v ast::Pat) {
+        impl ::visit::Visitor for PatIdentVisitor {
+            fn visit_pat(&mut self, p: &ast::Pat) {
                 match p.node {
                     PatKind::Ident(_ , ref spannedident, _) => {
                         self.spans.push(spannedident.span.clone());
diff --git a/src/libsyntax/show_span.rs b/src/libsyntax/show_span.rs
@@ -44,7 +44,7 @@ struct ShowSpanVisitor<'a> {
     mode: Mode,
 }
 
-impl<'a, 'v> Visitor<'v> for ShowSpanVisitor<'a> {
+impl<'a> Visitor for ShowSpanVisitor<'a> {
     fn visit_expr(&mut self, e: &ast::Expr) {
         if let Mode::Expression = self.mode {
             self.span_diagnostic.span_warn(e.span, "expression");
diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ impl<'a> CheckAttrVisitor<'a> {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-impl<'a, 'v> Visitor<'v> for CheckAttrVisitor<'a> {`
	`98`	`+impl<'a> Visitor for CheckAttrVisitor<'a> {`
`99`	`99`	`fn visit_item(&mut self, item: &ast::Item) {`
`100`	`100`	`let target = Target::from_item(item);`
`101`	`101`	`for attr in &item.attrs {`
Original file line number	Diff line number	Diff line change
`@@ -138,8 +138,8 @@ impl<'a> LoweringContext<'a> {`
`138`	`138`	`lctx: &'lcx mut LoweringContext<'interner>,`
`139`	`139`	`}`
`140`	`140`
`141`		`- impl<'lcx, 'interner> Visitor<'lcx> for ItemLowerer<'lcx, 'interner> {`
`142`		`- fn visit_item(&mut self, item: &'lcx Item) {`
	`141`	`+ impl<'lcx, 'interner> Visitor for ItemLowerer<'lcx, 'interner> {`
	`142`	`+ fn visit_item(&mut self, item: &Item) {`
`143`	`143`	`self.items.insert(item.id, self.lctx.lower_item(item));`
`144`	`144`	`visit::walk_item(self, item);`
`145`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ impl<'ast> DefCollector<'ast> {`
`98`	`98`	`self.parent_def = parent;`
`99`	`99`	`}`
`100`	`100`
`101`		`- fn visit_ast_const_integer(&mut self, expr: &'ast Expr) {`
	`101`	`+ fn visit_ast_const_integer(&mut self, expr: &Expr) {`
`102`	`102`	`// Find the node which will be used after lowering.`
`103`	`103`	`if let ExprKind::Paren(ref inner) = expr.node {`
`104`	`104`	`return self.visit_ast_const_integer(inner);`
`@@ -124,8 +124,8 @@ impl<'ast> DefCollector<'ast> {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`-impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {`
`128`		`- fn visit_item(&mut self, i: &'ast Item) {`
	`127`	`+impl<'ast> visit::Visitor for DefCollector<'ast> {`
	`128`	`+ fn visit_item(&mut self, i: &Item) {`
`129`	`129`	`debug!("visit_item: {:?}", i);`
`130`	`130`
`131`	`131`	`// Pick the def data. This need not be unique, but the more`
`@@ -183,23 +183,23 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {`
`183`	`183`	`});`
`184`	`184`	`}`
`185`	`185`
`186`		`- fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) {`
	`186`	`+ fn visit_foreign_item(&mut self, foreign_item: &ForeignItem) {`
`187`	`187`	`let def = self.create_def(foreign_item.id, DefPathData::ValueNs(foreign_item.ident.name));`
`188`	`188`
`189`	`189`	`self.with_parent(def, \|this\| {`
`190`	`190`	`visit::walk_foreign_item(this, foreign_item);`
`191`	`191`	`});`
`192`	`192`	`}`
`193`	`193`
`194`		`- fn visit_generics(&mut self, generics: &'ast Generics) {`
	`194`	`+ fn visit_generics(&mut self, generics: &Generics) {`
`195`	`195`	`for ty_param in generics.ty_params.iter() {`
`196`	`196`	`self.create_def(ty_param.id, DefPathData::TypeParam(ty_param.ident.name));`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`visit::walk_generics(self, generics);`
`200`	`200`	`}`
`201`	`201`
`202`		`- fn visit_trait_item(&mut self, ti: &'ast TraitItem) {`
	`202`	`+ fn visit_trait_item(&mut self, ti: &TraitItem) {`
`203`	`203`	`let def_data = match ti.node {`
`204`	`204`	`TraitItemKind::Method(..) \| TraitItemKind::Const(..) =>`
`205`	`205`	`DefPathData::ValueNs(ti.ident.name),`
`@@ -216,7 +216,7 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {`
`216`	`216`	`});`
`217`	`217`	`}`
`218`	`218`
`219`		`- fn visit_impl_item(&mut self, ii: &'ast ImplItem) {`
	`219`	`+ fn visit_impl_item(&mut self, ii: &ImplItem) {`
`220`	`220`	`let def_data = match ii.node {`
`221`	`221`	`ImplItemKind::Method(..) \| ImplItemKind::Const(..) =>`
`222`	`222`	`DefPathData::ValueNs(ii.ident.name),`
`@@ -234,7 +234,7 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {`
`234`	`234`	`});`
`235`	`235`	`}`
`236`	`236`
`237`		`- fn visit_pat(&mut self, pat: &'ast Pat) {`
	`237`	`+ fn visit_pat(&mut self, pat: &Pat) {`
`238`	`238`	`let parent_def = self.parent_def;`
`239`	`239`
`240`	`240`	`if let PatKind::Ident(_, id, _) = pat.node {`
`@@ -246,7 +246,7 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {`
`246`	`246`	`self.parent_def = parent_def;`
`247`	`247`	`}`
`248`	`248`
`249`		`- fn visit_expr(&mut self, expr: &'ast Expr) {`
	`249`	`+ fn visit_expr(&mut self, expr: &Expr) {`
`250`	`250`	`let parent_def = self.parent_def;`
`251`	`251`
`252`	`252`	`if let ExprKind::Repeat(_, ref count) = expr.node {`
`@@ -262,18 +262,18 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {`
`262`	`262`	`self.parent_def = parent_def;`
`263`	`263`	`}`
`264`	`264`
`265`		`- fn visit_ty(&mut self, ty: &'ast Ty) {`
	`265`	`+ fn visit_ty(&mut self, ty: &Ty) {`
`266`	`266`	`if let TyKind::FixedLengthVec(_, ref length) = ty.node {`
`267`	`267`	`self.visit_ast_const_integer(length);`
`268`	`268`	`}`
`269`	`269`	`visit::walk_ty(self, ty);`
`270`	`270`	`}`
`271`	`271`
`272`		`- fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) {`
	`272`	`+ fn visit_lifetime_def(&mut self, def: &LifetimeDef) {`
`273`	`273`	`self.create_def(def.lifetime.id, DefPathData::LifetimeDef(def.lifetime.name));`
`274`	`274`	`}`
`275`	`275`
`276`		`- fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) {`
	`276`	`+ fn visit_macro_def(&mut self, macro_def: &MacroDef) {`
`277`	`277`	`self.create_def(macro_def.id, DefPathData::MacroDef(macro_def.ident.name));`
`278`	`278`	`}`
`279`	`279`	`}`
Original file line number	Diff line number	Diff line change
`@@ -905,7 +905,7 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {`
`905`	`905`	`}`
`906`	`906`	`}`
`907`	`907`
`908`		`-impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {`
	`908`	`+impl<'a> ast_visit::Visitor for EarlyContext<'a> {`
`909`	`909`	`fn visit_item(&mut self, it: &ast::Item) {`
`910`	`910`	`self.with_lint_attrs(&it.attrs, \|cx\| {`
`911`	`911`	`run_lints!(cx, check_item, early_passes, it);`
`@@ -939,8 +939,8 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {`
`939`	`939`	`ast_visit::walk_stmt(self, s);`
`940`	`940`	`}`
`941`	`941`
`942`		`- fn visit_fn(&mut self, fk: ast_visit::FnKind<'v>, decl: &'v ast::FnDecl,`
`943`		`- body: &'v ast::Block, span: Span, id: ast::NodeId) {`
	`942`	`+ fn visit_fn(&mut self, fk: ast_visit::FnKind, decl: &ast::FnDecl,`
	`943`	`+ body: &ast::Block, span: Span, id: ast::NodeId) {`
`944`	`944`	`run_lints!(self, check_fn, early_passes, fk, decl, body, span, id);`
`945`	`945`	`ast_visit::walk_fn(self, fk, decl, body, span);`
`946`	`946`	`run_lints!(self, check_fn_post, early_passes, fk, decl, body, span, id);`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,8 @@ pub struct CrateReader<'a> {`
`58`	`58`	`local_crate_name: String,`
`59`	`59`	`}`
`60`	`60`
`61`		`-impl<'a, 'ast> visit::Visitor<'ast> for LocalCrateReader<'a> {`
`62`		`- fn visit_item(&mut self, a: &'ast ast::Item) {`
	`61`	`+impl<'a> visit::Visitor for LocalCrateReader<'a> {`
	`62`	`+ fn visit_item(&mut self, a: &ast::Item) {`
`63`	`63`	`self.process_item(a);`
`64`	`64`	`visit::walk_item(self, a);`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ impl<'a> AstValidator<'a> {`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-impl<'a, 'v> Visitor<'v> for AstValidator<'a> {`
	`60`	`+impl<'a> Visitor for AstValidator<'a> {`
`61`	`61`	`fn visit_lifetime(&mut self, lt: &Lifetime) {`
`62`	`62`	`if lt.name.as_str() == "'_" {`
`63`	`63`	`self.session.add_lint(`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ struct CheckNoAsm<'a> {`
`29`	`29`	`sess: &'a Session,`
`30`	`30`	`}`
`31`	`31`
`32`		`-impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {`
	`32`	`+impl<'a> Visitor for CheckNoAsm<'a> {`
`33`	`33`	`fn visit_expr(&mut self, e: &ast::Expr) {`
`34`	`34`	`match e.node {`
`35`	`35`	`ast::ExprKind::InlineAsm(_) => span_err!(self.sess, e.span, E0472,`
Original file line number	Diff line number	Diff line change
`@@ -503,7 +503,7 @@ struct BuildReducedGraphVisitor<'a, 'b: 'a> {`
`503`	`503`	`parent: Module<'b>,`
`504`	`504`	`}`
`505`	`505`
`506`		`-impl<'a, 'b, 'v> Visitor<'v> for BuildReducedGraphVisitor<'a, 'b> {`
	`506`	`+impl<'a, 'b> Visitor for BuildReducedGraphVisitor<'a, 'b> {`
`507`	`507`	`fn visit_item(&mut self, item: &Item) {`
`508`	`508`	`let old_parent = self.parent;`
`509`	`509`	`self.resolver.build_reduced_graph_for_item(item, &mut self.parent);`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-impl<'a, 'b, 'v> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b> {`
	`74`	`+impl<'a, 'b> Visitor for UnusedImportCheckVisitor<'a, 'b> {`
`75`	`75`	`fn visit_item(&mut self, item: &ast::Item) {`
`76`	`76`	`visit::walk_item(self, item);`
`77`	`77`	`// Ignore is_public import statements because there's no way to be sure`