Switch to new <V:Visitor> visitor (rather than @visitor).

Alpha-renamed top-level visit_* functions to walk_*.
(Motivation: Distinguish visit action and recursive traversal.)

Abstract over `&mut self` rather than over `@mut self`.

This required some acrobatics, notably the

  `impl<E> Visitor<E> for @mut Visitor<E>`

and corresponding introduction of `@mut Visitor` and some local `let
mut` bindings.

Remove oldvisit reference.

Added default implementations for all of the Visitor trait methods.

Note that both `visit_expr_post` and `visit_ty` are no-op's by
default, just like they are in `oldvisit::default_visitor`.

Refactoring: extract logic to ease swapping visit for oldvisit (hopefully).

Author: pnkfelix

src/librustc/middle/lint.rs

@@ -480,6 +480,7 @@ impl Context {
                             (orig.visit_item)(it, (self, stopping));
                         }
                         NewVisitor(new_visitor) => {
+                            let mut new_visitor = new_visitor;
                             new_visitor.visit_item(it, ());
                         }
                     }
@@ -492,7 +493,8 @@ impl Context {
                             oldvisit::visit_crate(c, (self, stopping))
                         }
                         NewVisitor(new_visitor) => {
-                            visit::visit_crate(new_visitor, c, ())
+                            let mut new_visitor = new_visitor;
+                            visit::walk_crate(&mut new_visitor, c, ())
                         }
                     }
                 }
@@ -518,6 +520,7 @@ impl Context {
                             let fk = visit::fk_method(m.ident,
                                                       &m.generics,
                                                       m);
+                            let mut new_visitor = new_visitor;
                             new_visitor.visit_fn(&fk,
                                                  &m.decl,
                                                  &m.body,

src/libsyntax/ast_map.rs

@@ -89,11 +89,11 @@ pub struct Ctx {
 }
 
 impl Ctx {
-    fn extend(@mut self, elt: ident) -> @path {
+    fn extend(&self, elt: ident) -> @path {
         @vec::append(self.path.clone(), [path_name(elt)])
     }
 
-    fn map_method(@mut self,
+    fn map_method(&mut self,
                   impl_did: def_id,
                   impl_path: @path,
                   m: @method,
@@ -107,7 +107,7 @@ impl Ctx {
         self.map.insert(m.self_id, node_local(special_idents::self_));
     }
 
-    fn map_struct_def(@mut self,
+    fn map_struct_def(&mut self,
                       struct_def: @ast::struct_def,
                       parent_node: ast_node,
                       ident: ast::ident) {
@@ -130,7 +130,7 @@ impl Ctx {
         }
     }
 
-    fn map_expr(@mut self, ex: @expr) {
+    fn map_expr(&mut self, ex: @expr) {
         self.map.insert(ex.id, node_expr(ex));
 
         // Expressions which are or might be calls:
@@ -141,10 +141,10 @@ impl Ctx {
             }
         }
 
-        visit::visit_expr(self as @mut Visitor<()>, ex, ());
+        visit::walk_expr(self, ex, ());
     }
 
-    fn map_fn(@mut self,
+    fn map_fn(&mut self,
               fk: &visit::fn_kind,
               decl: &fn_decl,
               body: &Block,
@@ -153,21 +153,21 @@ impl Ctx {
         for a in decl.inputs.iter() {
             self.map.insert(a.id, node_arg);
         }
-        visit::visit_fn(self as @mut Visitor<()>, fk, decl, body, sp, id, ());
+        visit::walk_fn(self, fk, decl, body, sp, id, ());
     }
 
-    fn map_stmt(@mut self, stmt: @stmt) {
+    fn map_stmt(&mut self, stmt: @stmt) {
         self.map.insert(stmt_id(stmt), node_stmt(stmt));
-        visit::visit_stmt(self as @mut Visitor<()>, stmt, ());
+        visit::walk_stmt(self, stmt, ());
     }
 
-    fn map_block(@mut self, b: &Block) {
+    fn map_block(&mut self, b: &Block) {
         // clone is FIXME #2543
         self.map.insert(b.id, node_block((*b).clone()));
-        visit::visit_block(self as @mut Visitor<()>, b, ());
+        visit::walk_block(self, b, ());
     }
 
-    fn map_pat(@mut self, pat: @pat) {
+    fn map_pat(&mut self, pat: @pat) {
         match pat.node {
             pat_ident(_, ref path, _) => {
                 // Note: this is at least *potentially* a pattern...
@@ -177,20 +177,21 @@ impl Ctx {
             _ => ()
         }
 
-        visit::visit_pat(self as @mut Visitor<()>, pat, ());
+        visit::walk_pat(self, pat, ());
     }
 }
 
 impl Visitor<()> for Ctx {
-    fn visit_item(@mut self, i: @item, _: ()) {
+    fn visit_item(&mut self, i: @item, _: ()) {
         // clone is FIXME #2543
         let item_path = @self.path.clone();
         self.map.insert(i.id, node_item(i, item_path));
         match i.node {
             item_impl(_, _, _, ref ms) => {
                 let impl_did = ast_util::local_def(i.id);
                 for m in ms.iter() {
-                    self.map_method(impl_did, self.extend(i.ident), *m, false)
+                    let extended = { self.extend(i.ident) };
+                    self.map_method(impl_did, extended, *m, false)
                 }
             }
             item_enum(ref enum_definition, _) => {
@@ -254,24 +255,24 @@ impl Visitor<()> for Ctx {
             }
             _ => self.path.push(path_name(i.ident))
         }
-        visit::visit_item(self as @mut Visitor<()>, i, ());
+        visit::walk_item(self, i, ());
         self.path.pop();
     }
 
-    fn visit_pat(@mut self, pat: @pat, _: ()) {
+    fn visit_pat(&mut self, pat: @pat, _: ()) {
         self.map_pat(pat);
-        visit::visit_pat(self as @mut Visitor<()>, pat, ())
+        visit::walk_pat(self, pat, ())
     }
 
-    fn visit_expr(@mut self, expr: @expr, _: ()) {
+    fn visit_expr(&mut self, expr: @expr, _: ()) {
         self.map_expr(expr)
     }
 
-    fn visit_stmt(@mut self, stmt: @stmt, _: ()) {
+    fn visit_stmt(&mut self, stmt: @stmt, _: ()) {
         self.map_stmt(stmt)
     }
 
-    fn visit_fn(@mut self,
+    fn visit_fn(&mut self,
                 function_kind: &fn_kind,
                 function_declaration: &fn_decl,
                 block: &Block,
@@ -281,56 +282,56 @@ impl Visitor<()> for Ctx {
         self.map_fn(function_kind, function_declaration, block, span, node_id)
     }
 
-    fn visit_block(@mut self, block: &Block, _: ()) {
+    fn visit_block(&mut self, block: &Block, _: ()) {
         self.map_block(block)
     }
 
     // XXX: Methods below can become default methods.
 
-    fn visit_mod(@mut self, module: &_mod, _: span, _: NodeId, _: ()) {
-        visit::visit_mod(self as @mut Visitor<()>, module, ())
+    fn visit_mod(&mut self, module: &_mod, _: span, _: NodeId, _: ()) {
+        visit::walk_mod(self, module, ())
     }
 
-    fn visit_view_item(@mut self, view_item: &view_item, _: ()) {
-        visit::visit_view_item(self as @mut Visitor<()>, view_item, ())
+    fn visit_view_item(&mut self, view_item: &view_item, _: ()) {
+        visit::walk_view_item(self, view_item, ())
     }
 
-    fn visit_foreign_item(@mut self, foreign_item: @foreign_item, _: ()) {
-        visit::visit_foreign_item(self as @mut Visitor<()>, foreign_item, ())
+    fn visit_foreign_item(&mut self, foreign_item: @foreign_item, _: ()) {
+        visit::walk_foreign_item(self, foreign_item, ())
     }
 
-    fn visit_local(@mut self, local: @Local, _: ()) {
-        visit::visit_local(self as @mut Visitor<()>, local, ())
+    fn visit_local(&mut self, local: @Local, _: ()) {
+        visit::walk_local(self, local, ())
     }
 
-    fn visit_arm(@mut self, arm: &arm, _: ()) {
-        visit::visit_arm(self as @mut Visitor<()>, arm, ())
+    fn visit_arm(&mut self, arm: &arm, _: ()) {
+        visit::walk_arm(self, arm, ())
     }
 
-    fn visit_decl(@mut self, decl: @decl, _: ()) {
-        visit::visit_decl(self as @mut Visitor<()>, decl, ())
+    fn visit_decl(&mut self, decl: @decl, _: ()) {
+        visit::walk_decl(self, decl, ())
     }
 
-    fn visit_expr_post(@mut self, _: @expr, _: ()) {
+    fn visit_expr_post(&mut self, _: @expr, _: ()) {
         // Empty!
     }
 
-    fn visit_ty(@mut self, typ: &Ty, _: ()) {
-        visit::visit_ty(self as @mut Visitor<()>, typ, ())
+    fn visit_ty(&mut self, typ: &Ty, _: ()) {
+        visit::walk_ty(self, typ, ())
     }
 
-    fn visit_generics(@mut self, generics: &Generics, _: ()) {
-        visit::visit_generics(self as @mut Visitor<()>, generics, ())
+    fn visit_generics(&mut self, generics: &Generics, _: ()) {
+        visit::walk_generics(self, generics, ())
     }
 
-    fn visit_fn(@mut self,
+    fn visit_fn(&mut self,
                 function_kind: &fn_kind,
                 function_declaration: &fn_decl,
                 block: &Block,
                 span: span,
                 node_id: NodeId,
                 _: ()) {
-        visit::visit_fn(self as @mut Visitor<()>,
+        visit::walk_fn(self,
                         function_kind,
                         function_declaration,
                         block,
@@ -339,30 +340,30 @@ impl Visitor<()> for Ctx {
                         ())
     }
 
-    fn visit_ty_method(@mut self, ty_method: &TypeMethod, _: ()) {
-        visit::visit_ty_method(self as @mut Visitor<()>, ty_method, ())
+    fn visit_ty_method(&mut self, ty_method: &TypeMethod, _: ()) {
+        visit::walk_ty_method(self, ty_method, ())
     }
 
-    fn visit_trait_method(@mut self, trait_method: &trait_method, _: ()) {
-        visit::visit_trait_method(self as @mut Visitor<()>, trait_method, ())
+    fn visit_trait_method(&mut self, trait_method: &trait_method, _: ()) {
+        visit::walk_trait_method(self, trait_method, ())
     }
 
-    fn visit_struct_def(@mut self,
+    fn visit_struct_def(&mut self,
                         struct_def: @struct_def,
                         ident: ident,
                         generics: &Generics,
                         node_id: NodeId,
                         _: ()) {
-        visit::visit_struct_def(self as @mut Visitor<()>,
+        visit::walk_struct_def(self,
                                 struct_def,
                                 ident,
                                 generics,
                                 node_id,
                                 ())
     }
 
-    fn visit_struct_field(@mut self, struct_field: @struct_field, _: ()) {
-        visit::visit_struct_field(self as @mut Visitor<()>, struct_field, ())
+    fn visit_struct_field(&mut self, struct_field: @struct_field, _: ()) {
+        visit::walk_struct_field(self, struct_field, ())
     }
 }
 
@@ -372,7 +373,7 @@ pub fn map_crate(diag: @mut span_handler, c: &Crate) -> map {
         path: ~[],
         diag: diag,
     };
-    visit::visit_crate(cx as @mut Visitor<()>, c, ());
+    visit::walk_crate(cx, c, ());
     cx.map
 }
 
@@ -409,7 +410,7 @@ pub fn map_decoded_item(diag: @mut span_handler,
     }
 
     // visit the item / method contents and add those to the map:
-    ii.accept((), cx as @mut Visitor<()>);
+    ii.accept((), cx);
 }
 
 pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str {