Track the visited AST's lifetime throughout Visitor.

3 files changed, 130 insertions, 147 deletions

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 3db71c6d309..ff733673bd2 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -366,7 +366,7 @@ impl<'a, O: IdVisitingOperation> IdVisitor<'a, O> {
     }
 }
 
-impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> {
+impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
     fn visit_mod(&mut self,
                  module: &Mod,
                  _: Span,
@@ -475,13 +475,13 @@ impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> {
     }
 
     fn visit_fn(&mut self,
-                function_kind: &visit::FnKind,
-                function_declaration: &FnDecl,
-                block: &Block,
+                function_kind: visit::FnKind<'v>,
+                function_declaration: &'v FnDecl,
+                block: &'v Block,
                 span: Span,
                 node_id: NodeId) {
         if !self.pass_through_items {
-            match *function_kind {
+            match function_kind {
                 visit::FkMethod(..) if self.visited_outermost => return,
                 visit::FkMethod(..) => self.visited_outermost = true,
                 _ => {}
@@ -490,7 +490,7 @@ impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> {
 
         self.operation.visit_id(node_id);
 
-        match *function_kind {
+        match function_kind {
             visit::FkItemFn(_, generics, _, _) |
             visit::FkMethod(_, generics, _) => {
                 self.visit_generics_helper(generics)
@@ -509,7 +509,7 @@ impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> {
                         span);
 
         if !self.pass_through_items {
-            match *function_kind {
+            match function_kind {
                 visit::FkMethod(..) => self.visited_outermost = false,
                 _ => {}
             }
@@ -571,7 +571,7 @@ pub fn compute_id_range_for_inlined_item(item: &InlinedItem) -> IdRange {
     visitor.result.get()
 }
 
-pub fn compute_id_range_for_fn_body(fk: &visit::FnKind,
+pub fn compute_id_range_for_fn_body(fk: visit::FnKind,
                                     decl: &FnDecl,
                                     body: &Block,
                                     sp: Span,
@@ -639,7 +639,7 @@ struct EachViewItemData<'a> {
     callback: |&ast::ViewItem|: 'a -> bool,
 }
 
-impl<'a> Visitor for EachViewItemData<'a> {
+impl<'a, 'v> Visitor<'v> for EachViewItemData<'a> {
     fn visit_view_item(&mut self, view_item: &ast::ViewItem) {
         let _ = (self.callback)(view_item);
     }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 04df6d618e9..8b10c26c43c 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -651,7 +651,7 @@ struct PatIdentFinder {
     ident_accumulator: Vec<ast::Ident>
 }
 
-impl Visitor for PatIdentFinder {
+impl<'v> Visitor<'v> for PatIdentFinder {
     fn visit_pat(&mut self, pattern: &ast::Pat) {
         match *pattern {
             ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => {
@@ -1107,7 +1107,7 @@ struct MacroExterminator<'a>{
     sess: &'a parse::ParseSess
 }
 
-impl<'a> Visitor for MacroExterminator<'a> {
+impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> {
     fn visit_mac(&mut self, macro: &ast::Mac) {
         self.sess.span_diagnostic.span_bug(macro.span,
                                            "macro exterminator: expected AST \
@@ -1144,7 +1144,7 @@ mod test {
         path_accumulator: Vec<ast::Path> ,
     }
 
-    impl Visitor for PathExprFinderContext {
+    impl<'v> Visitor<'v> for PathExprFinderContext {
         fn visit_expr(&mut self, expr: &ast::Expr) {
             match expr.node {
                 ast::ExprPath(ref p) => {
@@ -1169,7 +1169,7 @@ mod test {
         ident_accumulator: Vec<ast::Ident>
     }
 
-    impl Visitor for IdentFinder {
+    impl<'v> Visitor<'v> for IdentFinder {
         fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){
             self.ident_accumulator.push(id);
         }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index c31082ddf59..2a989e6d63a 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -26,9 +26,7 @@
 use abi::Abi;
 use ast::*;
 use ast;
-use ast_util;
 use codemap::Span;
-use parse;
 use owned_slice::OwnedSlice;
 
 use std::gc::Gc;
@@ -45,23 +43,6 @@ pub enum FnKind<'a> {
     FkFnBlock,
 }
 
-pub fn name_of_fn(fk: &FnKind) -> Ident {
-    match *fk {
-        FkItemFn(name, _, _, _) | FkMethod(name, _, _) => name,
-        FkFnBlock(..) => parse::token::special_idents::invalid
-    }
-}
-
-pub fn generics_of_fn(fk: &FnKind) -> Generics {
-    match *fk {
-        FkItemFn(_, generics, _, _) |
-        FkMethod(_, generics, _) => {
-            (*generics).clone()
-        }
-        FkFnBlock(..) => ast_util::empty_generics(),
-    }
-}
-
 /// Each method of the Visitor trait is a hook to be potentially
 /// overridden.  Each method's default implementation recursively visits
 /// the substructure of the input via the corresponding `walk` method;
@@ -71,38 +52,38 @@ pub fn generics_of_fn(fk: &FnKind) -> Generics {
 /// explicitly, you need to override each method.  (And you also need
 /// to monitor future changes to `Visitor` in case a new method with a
 /// new default implementation gets introduced.)
-pub trait Visitor {
+pub trait Visitor<'v> {
 
     fn visit_ident(&mut self, _sp: Span, _ident: Ident) {
         /*! Visit the idents */
     }
-    fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId) { walk_mod(self, m) }
-    fn visit_view_item(&mut self, i: &ViewItem) { walk_view_item(self, i) }
-    fn visit_foreign_item(&mut self, i: &ForeignItem) { walk_foreign_item(self, i) }
-    fn visit_item(&mut self, i: &Item) { walk_item(self, i) }
-    fn visit_local(&mut self, l: &Local) { walk_local(self, l) }
-    fn visit_block(&mut self, b: &Block) { walk_block(self, b) }
-    fn visit_stmt(&mut self, s: &Stmt) { walk_stmt(self, s) }
-    fn visit_arm(&mut self, a: &Arm) { walk_arm(self, a) }
-    fn visit_pat(&mut self, p: &Pat) { walk_pat(self, p) }
-    fn visit_decl(&mut self, d: &Decl) { walk_decl(self, d) }
-    fn visit_expr(&mut self, ex: &Expr) { walk_expr(self, ex) }
-    fn visit_expr_post(&mut self, _ex: &Expr) { }
-    fn visit_ty(&mut self, t: &Ty) { walk_ty(self, t) }
-    fn visit_generics(&mut self, g: &Generics) { walk_generics(self, g) }
-    fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
+    fn visit_mod(&mut self, m: &'v Mod, _s: Span, _n: NodeId) { walk_mod(self, m) }
+    fn visit_view_item(&mut self, i: &'v ViewItem) { walk_view_item(self, i) }
+    fn visit_foreign_item(&mut self, i: &'v ForeignItem) { walk_foreign_item(self, i) }
+    fn visit_item(&mut self, i: &'v Item) { walk_item(self, i) }
+    fn visit_local(&mut self, l: &'v Local) { walk_local(self, l) }
+    fn visit_block(&mut self, b: &'v Block) { walk_block(self, b) }
+    fn visit_stmt(&mut self, s: &'v Stmt) { walk_stmt(self, s) }
+    fn visit_arm(&mut self, a: &'v Arm) { walk_arm(self, a) }
+    fn visit_pat(&mut self, p: &'v Pat) { walk_pat(self, p) }
+    fn visit_decl(&mut self, d: &'v Decl) { walk_decl(self, d) }
+    fn visit_expr(&mut self, ex: &'v Expr) { walk_expr(self, ex) }
+    fn visit_expr_post(&mut self, _ex: &'v Expr) { }
+    fn visit_ty(&mut self, t: &'v Ty) { walk_ty(self, t) }
+    fn visit_generics(&mut self, g: &'v Generics) { walk_generics(self, g) }
+    fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, _: NodeId) {
         walk_fn(self, fk, fd, b, s)
     }
-    fn visit_ty_method(&mut self, t: &TypeMethod) { walk_ty_method(self, t) }
-    fn visit_trait_item(&mut self, t: &TraitItem) { walk_trait_item(self, t) }
-    fn visit_struct_def(&mut self, s: &StructDef, _: Ident, _: &Generics, _: NodeId) {
+    fn visit_ty_method(&mut self, t: &'v TypeMethod) { walk_ty_method(self, t) }
+    fn visit_trait_item(&mut self, t: &'v TraitItem) { walk_trait_item(self, t) }
+    fn visit_struct_def(&mut self, s: &'v StructDef, _: Ident, _: &'v Generics, _: NodeId) {
         walk_struct_def(self, s)
     }
-    fn visit_struct_field(&mut self, s: &StructField) { walk_struct_field(self, s) }
-    fn visit_variant(&mut self, v: &Variant, g: &Generics) { walk_variant(self, v, g) }
+    fn visit_struct_field(&mut self, s: &'v StructField) { walk_struct_field(self, s) }
+    fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) { walk_variant(self, v, g) }
     fn visit_opt_lifetime_ref(&mut self,
                               _span: Span,
-                              opt_lifetime: &Option<Lifetime>) {
+                              opt_lifetime: &'v Option<Lifetime>) {
         /*!
          * Visits an optional reference to a lifetime. The `span` is
          * the span of some surrounding reference should opt_lifetime
@@ -113,16 +94,16 @@ pub trait Visitor {
             None => ()
         }
     }
-    fn visit_lifetime_ref(&mut self, _lifetime: &Lifetime) {
+    fn visit_lifetime_ref(&mut self, _lifetime: &'v Lifetime) {
         /*! Visits a reference to a lifetime */
     }
-    fn visit_lifetime_decl(&mut self, _lifetime: &LifetimeDef) {
+    fn visit_lifetime_decl(&mut self, _lifetime: &'v LifetimeDef) {
         /*! Visits a declaration of a lifetime */
     }
-    fn visit_explicit_self(&mut self, es: &ExplicitSelf) {
+    fn visit_explicit_self(&mut self, es: &'v ExplicitSelf) {
         walk_explicit_self(self, es)
     }
-    fn visit_mac(&mut self, _macro: &Mac) {
+    fn visit_mac(&mut self, _macro: &'v Mac) {
         fail!("visit_mac disabled by default");
         // NB: see note about macros above.
         // if you really want a visitor that
@@ -130,23 +111,23 @@ pub trait Visitor {
         // definition in your trait impl:
         // visit::walk_mac(self, _macro)
     }
-    fn visit_path(&mut self, path: &Path, _id: ast::NodeId) {
+    fn visit_path(&mut self, path: &'v Path, _id: ast::NodeId) {
         walk_path(self, path)
     }
-    fn visit_attribute(&mut self, _attr: &Attribute) {}
+    fn visit_attribute(&mut self, _attr: &'v Attribute) {}
 }
 
-pub fn walk_inlined_item<V: Visitor>(visitor: &mut V, item: &ast::InlinedItem) {
+pub fn walk_inlined_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v InlinedItem) {
     match *item {
-        IIItem(i) => visitor.visit_item(&*i),
-        IIForeign(i) => visitor.visit_foreign_item(&*i),
-        IITraitItem(_, iti) => {
-            match iti {
-                ProvidedInlinedTraitItem(m) => {
-                    walk_method_helper(visitor, &*m)
+        IIItem(ref i) => visitor.visit_item(&**i),
+        IIForeign(ref i) => visitor.visit_foreign_item(&**i),
+        IITraitItem(_, ref iti) => {
+            match *iti {
+                ProvidedInlinedTraitItem(ref m) => {
+                    walk_method_helper(visitor, &**m)
                 }
-                RequiredInlinedTraitItem(m) => {
-                    walk_method_helper(visitor, &*m)
+                RequiredInlinedTraitItem(ref m) => {
+                    walk_method_helper(visitor, &**m)
                 }
             }
         }
@@ -154,14 +135,14 @@ pub fn walk_inlined_item<V: Visitor>(visitor: &mut V, item: &ast::InlinedItem) {
 }
 
 
-pub fn walk_crate<V: Visitor>(visitor: &mut V, krate: &Crate) {
+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.iter() {
         visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_mod<V: Visitor>(visitor: &mut V, module: &Mod) {
+pub fn walk_mod<'v, V: Visitor<'v>>(visitor: &mut V, module: &'v Mod) {
     for view_item in module.view_items.iter() {
         visitor.visit_view_item(view_item)
     }
@@ -171,7 +152,7 @@ pub fn walk_mod<V: Visitor>(visitor: &mut V, module: &Mod) {
     }
 }
 
-pub fn walk_view_item<V: Visitor>(visitor: &mut V, vi: &ViewItem) {
+pub fn walk_view_item<'v, V: Visitor<'v>>(visitor: &mut V, vi: &'v ViewItem) {
     match vi.node {
         ViewItemExternCrate(name, _, _) => {
             visitor.visit_ident(vi.span, name)
@@ -204,16 +185,14 @@ pub fn walk_view_item<V: Visitor>(visitor: &mut V, vi: &ViewItem) {
     }
 }
 
-pub fn walk_local<V: Visitor>(visitor: &mut V, local: &Local) {
+pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local) {
     visitor.visit_pat(&*local.pat);
     visitor.visit_ty(&*local.ty);
-    match local.init {
-        None => {}
-        Some(initializer) => visitor.visit_expr(&*initializer),
-    }
+    walk_expr_opt(visitor, &local.init);
 }
 
-pub fn walk_explicit_self<V: Visitor>(visitor: &mut V, explicit_self: &ExplicitSelf) {
+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, _, _) => {
@@ -225,21 +204,21 @@ pub fn walk_explicit_self<V: Visitor>(visitor: &mut V, explicit_self: &ExplicitS
 
 /// Like with walk_method_helper this doesn't correspond to a method
 /// in Visitor, and so it gets a _helper suffix.
-pub fn walk_trait_ref_helper<V: Visitor>(visitor: &mut V, trait_ref: &TraitRef) {
+pub fn walk_trait_ref_helper<'v, V: Visitor<'v>>(visitor: &mut V, trait_ref: &'v TraitRef) {
     visitor.visit_path(&trait_ref.path, trait_ref.ref_id)
 }
 
-pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
+pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
     visitor.visit_ident(item.span, item.ident);
     match item.node {
         ItemStatic(ref typ, _, ref expr) => {
             visitor.visit_ty(&**typ);
             visitor.visit_expr(&**expr);
         }
-        ItemFn(declaration, fn_style, abi, ref generics, body) => {
-            visitor.visit_fn(&FkItemFn(item.ident, generics, fn_style, abi),
-                             &*declaration,
-                             &*body,
+        ItemFn(ref declaration, fn_style, abi, ref generics, ref body) => {
+            visitor.visit_fn(FkItemFn(item.ident, generics, fn_style, abi),
+                             &**declaration,
+                             &**body,
                              item.span,
                              item.id)
         }
@@ -264,7 +243,7 @@ pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
         }
         ItemImpl(ref type_parameters,
                  ref trait_reference,
-                 typ,
+                 ref typ,
                  ref impl_items) => {
             visitor.visit_generics(type_parameters);
             match *trait_reference {
@@ -272,11 +251,11 @@ pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
                                                                    trait_reference),
                 None => ()
             }
-            visitor.visit_ty(&*typ);
+            visitor.visit_ty(&**typ);
             for impl_item in impl_items.iter() {
                 match *impl_item {
-                    MethodImplItem(method) => {
-                        walk_method_helper(visitor, &*method)
+                    MethodImplItem(ref method) => {
+                        walk_method_helper(visitor, &**method)
                     }
                 }
             }
@@ -302,17 +281,17 @@ pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
     }
 }
 
-pub fn walk_enum_def<V: Visitor>(visitor: &mut V,
-                                 enum_definition: &EnumDef,
-                                 generics: &Generics) {
-    for &variant in enum_definition.variants.iter() {
-        visitor.visit_variant(&*variant, generics);
+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.iter() {
+        visitor.visit_variant(&**variant, generics);
     }
 }
 
-pub fn walk_variant<V: Visitor>(visitor: &mut V,
-                                variant: &Variant,
-                                generics: &Generics) {
+pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
+                                        variant: &'v Variant,
+                                        generics: &'v Generics) {
     visitor.visit_ident(variant.span, variant.node.name);
 
     match variant.node.kind {
@@ -337,14 +316,14 @@ pub fn walk_variant<V: Visitor>(visitor: &mut V,
     }
 }
 
-pub fn skip_ty<V: Visitor>(_: &mut V, _: &Ty) {
+pub fn skip_ty<'v, V: Visitor<'v>>(_: &mut V, _: &'v Ty) {
     // Empty!
 }
 
-pub fn walk_ty<V: Visitor>(visitor: &mut V, typ: &Ty) {
+pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
     match typ.node {
-        TyUniq(ty) | TyVec(ty) | TyBox(ty) | TyParen(ty) => {
-            visitor.visit_ty(&*ty)
+        TyUniq(ref ty) | TyVec(ref ty) | TyBox(ref ty) | TyParen(ref ty) => {
+            visitor.visit_ty(&**ty)
         }
         TyPtr(ref mutable_type) => {
             visitor.visit_ty(&*mutable_type.ty)
@@ -354,8 +333,8 @@ pub fn walk_ty<V: Visitor>(visitor: &mut V, typ: &Ty) {
             visitor.visit_ty(&*mutable_type.ty)
         }
         TyTup(ref tuple_element_types) => {
-            for &tuple_element_type in tuple_element_types.iter() {
-                visitor.visit_ty(&*tuple_element_type)
+            for tuple_element_type in tuple_element_types.iter() {
+                visitor.visit_ty(&**tuple_element_type)
             }
         }
         TyClosure(ref function_declaration) => {
@@ -407,13 +386,14 @@ pub fn walk_ty<V: Visitor>(visitor: &mut V, typ: &Ty) {
     }
 }
 
-fn walk_lifetime_decls<V: Visitor>(visitor: &mut V, lifetimes: &Vec<LifetimeDef>) {
+fn walk_lifetime_decls<'v, V: Visitor<'v>>(visitor: &mut V,
+                                           lifetimes: &'v Vec<LifetimeDef>) {
     for l in lifetimes.iter() {
         visitor.visit_lifetime_decl(l);
     }
 }
 
-pub fn walk_path<V: Visitor>(visitor: &mut V, path: &Path) {
+pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
     for segment in path.segments.iter() {
         visitor.visit_ident(path.span, segment.identifier);
 
@@ -426,7 +406,7 @@ pub fn walk_path<V: Visitor>(visitor: &mut V, path: &Path) {
     }
 }
 
-pub fn walk_pat<V: Visitor>(visitor: &mut V, pattern: &Pat) {
+pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {
     match pattern.node {
         PatEnum(ref path, ref children) => {
             visitor.visit_path(path, pattern.id);
@@ -479,7 +459,8 @@ pub fn walk_pat<V: Visitor>(visitor: &mut V, pattern: &Pat) {
     }
 }
 
-pub fn walk_foreign_item<V: Visitor>(visitor: &mut V, foreign_item: &ForeignItem) {
+pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V,
+                                             foreign_item: &'v ForeignItem) {
     visitor.visit_ident(foreign_item.span, foreign_item.ident);
 
     match foreign_item.node {
@@ -495,8 +476,8 @@ pub fn walk_foreign_item<V: Visitor>(visitor: &mut V, foreign_item: &ForeignItem
     }
 }
 
-pub fn walk_ty_param_bounds<V: Visitor>(visitor: &mut V,
-                                        bounds: &OwnedSlice<TyParamBound>) {
+pub fn walk_ty_param_bounds<'v, V: Visitor<'v>>(visitor: &mut V,
+                                                bounds: &'v OwnedSlice<TyParamBound>) {
     for bound in bounds.iter() {
         match *bound {
             TraitTyParamBound(ref typ) => {
@@ -515,7 +496,7 @@ pub fn walk_ty_param_bounds<V: Visitor>(visitor: &mut V,
     }
 }
 
-pub fn walk_generics<V: Visitor>(visitor: &mut V, generics: &Generics) {
+pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics) {
     for type_parameter in generics.ty_params.iter() {
         walk_ty_param_bounds(visitor, &type_parameter.bounds);
         match type_parameter.default {
@@ -530,7 +511,7 @@ pub fn walk_generics<V: Visitor>(visitor: &mut V, generics: &Generics) {
     }
 }
 
-pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, function_declaration: &FnDecl) {
+pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl) {
     for argument in function_declaration.inputs.iter() {
         visitor.visit_pat(&*argument.pat);
         visitor.visit_ty(&*argument.ty)
@@ -542,13 +523,13 @@ pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, function_declaration: &FnDecl)
 // visit_fn() and check for FkMethod().  I named this visit_method_helper()
 // because it is not a default impl of any method, though I doubt that really
 // clarifies anything. - Niko
-pub fn walk_method_helper<V: Visitor>(visitor: &mut V, method: &Method) {
+pub fn walk_method_helper<'v, V: Visitor<'v>>(visitor: &mut V, method: &'v Method) {
     match method.node {
-        MethDecl(ident, ref generics, _, _, _, decl, body, _) => {
+        MethDecl(ident, ref generics, _, _, _, ref decl, ref body, _) => {
             visitor.visit_ident(method.span, ident);
-            visitor.visit_fn(&FkMethod(ident, generics, method),
-                             &*decl,
-                             &*body,
+            visitor.visit_fn(FkMethod(ident, generics, method),
+                             &**decl,
+                             &**body,
                              method.span,
                              method.id);
             for attr in method.attrs.iter() {
@@ -560,14 +541,14 @@ pub fn walk_method_helper<V: Visitor>(visitor: &mut V, method: &Method) {
     }
 }
 
-pub fn walk_fn<V: Visitor>(visitor: &mut V,
-                           function_kind: &FnKind,
-                           function_declaration: &FnDecl,
-                           function_body: &Block,
-                           _span: Span) {
+pub fn walk_fn<'v, V: Visitor<'v>>(visitor: &mut V,
+                                   function_kind: FnKind<'v>,
+                                   function_declaration: &'v FnDecl,
+                                   function_body: &'v Block,
+                                   _span: Span) {
     walk_fn_decl(visitor, function_declaration);
 
-    match *function_kind {
+    match function_kind {
         FkItemFn(_, generics, _, _) => {
             visitor.visit_generics(generics);
         }
@@ -586,7 +567,7 @@ pub fn walk_fn<V: Visitor>(visitor: &mut V,
     visitor.visit_block(function_body)
 }
 
-pub fn walk_ty_method<V: Visitor>(visitor: &mut V, method_type: &TypeMethod) {
+pub fn walk_ty_method<'v, V: Visitor<'v>>(visitor: &mut V, method_type: &'v TypeMethod) {
     visitor.visit_ident(method_type.span, method_type.ident);
     visitor.visit_explicit_self(&method_type.explicit_self);
     for argument_type in method_type.decl.inputs.iter() {
@@ -599,7 +580,7 @@ pub fn walk_ty_method<V: Visitor>(visitor: &mut V, method_type: &TypeMethod) {
     }
 }
 
-pub fn walk_trait_item<V: Visitor>(visitor: &mut V, trait_method: &TraitItem) {
+pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_method: &'v TraitItem) {
     match *trait_method {
         RequiredMethod(ref method_type) => {
             visitor.visit_ty_method(method_type)
@@ -608,8 +589,8 @@ pub fn walk_trait_item<V: Visitor>(visitor: &mut V, trait_method: &TraitItem) {
     }
 }
 
-pub fn walk_struct_def<V: Visitor>(visitor: &mut V,
-                                   struct_definition: &StructDef) {
+pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V,
+                                           struct_definition: &'v StructDef) {
     match struct_definition.super_struct {
         Some(ref t) => visitor.visit_ty(&**t),
         None => {},
@@ -619,8 +600,8 @@ pub fn walk_struct_def<V: Visitor>(visitor: &mut V,
     }
 }
 
-pub fn walk_struct_field<V: Visitor>(visitor: &mut V,
-                                     struct_field: &StructField) {
+pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V,
+                                             struct_field: &'v StructField) {
     match struct_field.node.kind {
         NamedField(name, _) => {
             visitor.visit_ident(struct_field.span, name)
@@ -635,17 +616,17 @@ pub fn walk_struct_field<V: Visitor>(visitor: &mut V,
     }
 }
 
-pub fn walk_block<V: Visitor>(visitor: &mut V, block: &Block) {
+pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block) {
     for view_item in block.view_items.iter() {
         visitor.visit_view_item(view_item)
     }
     for statement in block.stmts.iter() {
         visitor.visit_stmt(&**statement)
     }
-    walk_expr_opt(visitor, block.expr)
+    walk_expr_opt(visitor, &block.expr)
 }
 
-pub fn walk_stmt<V: Visitor>(visitor: &mut V, statement: &Stmt) {
+pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt) {
     match statement.node {
         StmtDecl(ref declaration, _) => visitor.visit_decl(&**declaration),
         StmtExpr(ref expression, _) | StmtSemi(ref expression, _) => {
@@ -655,32 +636,32 @@ pub fn walk_stmt<V: Visitor>(visitor: &mut V, statement: &Stmt) {
     }
 }
 
-pub fn walk_decl<V: Visitor>(visitor: &mut V, declaration: &Decl) {
+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: Visitor>(visitor: &mut V,
-                                 optional_expression: Option<Gc<Expr>>) {
-    match optional_expression {
+pub fn walk_expr_opt<'v, V: Visitor<'v>>(visitor: &mut V,
+                                         optional_expression: &'v Option<Gc<Expr>>) {
+    match *optional_expression {
         None => {}
         Some(ref expression) => visitor.visit_expr(&**expression),
     }
 }
 
-pub fn walk_exprs<V: Visitor>(visitor: &mut V, expressions: &[Gc<Expr>]) {
+pub fn walk_exprs<'v, V: Visitor<'v>>(visitor: &mut V, expressions: &'v [Gc<Expr>]) {
     for expression in expressions.iter() {
         visitor.visit_expr(&**expression)
     }
 }
 
-pub fn walk_mac<V: Visitor>(_: &mut V, _: &Mac) {
+pub fn walk_mac<'v, V: Visitor<'v>>(_: &mut V, _: &'v Mac) {
     // Empty!
 }
 
-pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
+pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
     match expression.node {
         ExprBox(ref place, ref subexpression) => {
             visitor.visit_expr(&**place);
@@ -693,7 +674,7 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
             visitor.visit_expr(&**element);
             visitor.visit_expr(&**count)
         }
-        ExprStruct(ref path, ref fields, optional_base) => {
+        ExprStruct(ref path, ref fields, ref optional_base) => {
             visitor.visit_path(path, expression.id);
             for field in fields.iter() {
                 visitor.visit_expr(&*field.expr)
@@ -729,7 +710,7 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
             visitor.visit_expr(&**subexpression);
             visitor.visit_ty(&**typ)
         }
-        ExprIf(ref head_expression, ref if_block, optional_else) => {
+        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)
@@ -751,21 +732,21 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
             }
         }
         ExprFnBlock(_, ref function_declaration, ref body) => {
-            visitor.visit_fn(&FkFnBlock,
+            visitor.visit_fn(FkFnBlock,
                              &**function_declaration,
                              &**body,
                              expression.span,
                              expression.id)
         }
         ExprUnboxedFn(_, _, ref function_declaration, ref body) => {
-            visitor.visit_fn(&FkFnBlock,
+            visitor.visit_fn(FkFnBlock,
                              &**function_declaration,
                              &**body,
                              expression.span,
                              expression.id)
         }
         ExprProc(ref function_declaration, ref body) => {
-            visitor.visit_fn(&FkFnBlock,
+            visitor.visit_fn(FkFnBlock,
                              &**function_declaration,
                              &**body,
                              expression.span,
@@ -800,7 +781,7 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
             visitor.visit_path(path, expression.id)
         }
         ExprBreak(_) | ExprAgain(_) => {}
-        ExprRet(optional_expression) => {
+        ExprRet(ref optional_expression) => {
             walk_expr_opt(visitor, optional_expression)
         }
         ExprMac(ref macro) => visitor.visit_mac(macro),
@@ -808,10 +789,12 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
             visitor.visit_expr(&**subexpression)
         }
         ExprInlineAsm(ref ia) => {
-            for &(_, ref input) in ia.inputs.iter() {
+            for input in ia.inputs.iter() {
+                let (_, ref input) = *input;
                 visitor.visit_expr(&**input)
             }
-            for &(_, ref output, _) in ia.outputs.iter() {
+            for output in ia.outputs.iter() {
+                let (_, ref output, _) = *output;
                 visitor.visit_expr(&**output)
             }
         }
@@ -820,11 +803,11 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
     visitor.visit_expr_post(expression)
 }
 
-pub fn walk_arm<V: Visitor>(visitor: &mut V, arm: &Arm) {
+pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm) {
     for pattern in arm.pats.iter() {
         visitor.visit_pat(&**pattern)
     }
-    walk_expr_opt(visitor, arm.guard);
+    walk_expr_opt(visitor, &arm.guard);
     visitor.visit_expr(&*arm.body);
     for attr in arm.attrs.iter() {
         visitor.visit_attribute(attr);