auto merge of #8539 : pnkfelix/rust/fsk-visitor-vpar-defaults-step2, r=graydon,nikomatsakis

r? @nikomatsakis

Follow up to #8527 (which was step 1 of 5).  See that for overall description 

Part of #7081

Author: bors

src/librustc/middle/check_const.rs

@@ -17,47 +17,71 @@ use util::ppaux;
 
 use syntax::ast::*;
 use syntax::codemap;
-use syntax::{oldvisit, ast_util, ast_map};
+use syntax::{ast_util, ast_map};
+use syntax::visit::Visitor;
+use syntax::visit;
+
+struct CheckCrateVisitor {
+    sess: Session,
+    ast_map: ast_map::map,
+    def_map: resolve::DefMap,
+    method_map: typeck::method_map,
+    tcx: ty::ctxt,
+}
+
+impl Visitor<bool> for CheckCrateVisitor {
+    fn visit_item(&mut self, i:@item, env:bool) {
+        check_item(self, self.sess, self.ast_map, self.def_map, i, env);
+    }
+    fn visit_pat(&mut self, p:@pat, env:bool) {
+        check_pat(self, p, env);
+    }
+    fn visit_expr(&mut self, ex:@expr, env:bool) {
+        check_expr(self, self.sess, self.def_map, self.method_map,
+                   self.tcx, ex, env);
+    }
+}
 
 pub fn check_crate(sess: Session,
                    crate: &Crate,
                    ast_map: ast_map::map,
                    def_map: resolve::DefMap,
                    method_map: typeck::method_map,
                    tcx: ty::ctxt) {
-    oldvisit::visit_crate(crate, (false, oldvisit::mk_vt(@oldvisit::Visitor {
-        visit_item: |a,b| check_item(sess, ast_map, def_map, a, b),
-        visit_pat: check_pat,
-        visit_expr: |a,b|
-            check_expr(sess, def_map, method_map, tcx, a, b),
-        .. *oldvisit::default_visitor()
-    })));
+    let mut v = CheckCrateVisitor {
+        sess: sess,
+        ast_map: ast_map,
+        def_map: def_map,
+        method_map: method_map,
+        tcx: tcx,
+    };
+    visit::walk_crate(&mut v, crate, false);
     sess.abort_if_errors();
 }
 
-pub fn check_item(sess: Session,
+pub fn check_item(v: &mut CheckCrateVisitor,
+                  sess: Session,
                   ast_map: ast_map::map,
                   def_map: resolve::DefMap,
                   it: @item,
-                  (_is_const, v): (bool,
-                                   oldvisit::vt<bool>)) {
+                  _is_const: bool) {
     match it.node {
       item_static(_, _, ex) => {
-        (v.visit_expr)(ex, (true, v));
+        v.visit_expr(ex, true);
         check_item_recursion(sess, ast_map, def_map, it);
       }
       item_enum(ref enum_definition, _) => {
         for var in (*enum_definition).variants.iter() {
             for ex in var.node.disr_expr.iter() {
-                (v.visit_expr)(*ex, (true, v));
+                v.visit_expr(*ex, true);
             }
         }
       }
-      _ => oldvisit::visit_item(it, (false, v))
+      _ => visit::walk_item(v, it, false)
     }
 }
 
-pub fn check_pat(p: @pat, (_is_const, v): (bool, oldvisit::vt<bool>)) {
+pub fn check_pat(v: &mut CheckCrateVisitor, p: @pat, _is_const: bool) {
     fn is_str(e: @expr) -> bool {
         match e.node {
             expr_vstore(
@@ -72,22 +96,22 @@ pub fn check_pat(p: @pat, (_is_const, v): (bool, oldvisit::vt<bool>)) {
     }
     match p.node {
       // Let through plain ~-string literals here
-      pat_lit(a) => if !is_str(a) { (v.visit_expr)(a, (true, v)); },
+      pat_lit(a) => if !is_str(a) { v.visit_expr(a, true); },
       pat_range(a, b) => {
-        if !is_str(a) { (v.visit_expr)(a, (true, v)); }
-        if !is_str(b) { (v.visit_expr)(b, (true, v)); }
+        if !is_str(a) { v.visit_expr(a, true); }
+        if !is_str(b) { v.visit_expr(b, true); }
       }
-      _ => oldvisit::visit_pat(p, (false, v))
+      _ => visit::walk_pat(v, p, false)
     }
 }
 
-pub fn check_expr(sess: Session,
+pub fn check_expr(v: &mut CheckCrateVisitor,
+                  sess: Session,
                   def_map: resolve::DefMap,
                   method_map: typeck::method_map,
                   tcx: ty::ctxt,
                   e: @expr,
-                  (is_const, v): (bool,
-                                  oldvisit::vt<bool>)) {
+                  is_const: bool) {
     if is_const {
         match e.node {
           expr_unary(_, deref, _) => { }
@@ -152,8 +176,8 @@ pub fn check_expr(sess: Session,
                 }
             }
           }
-          expr_paren(e) => { check_expr(sess, def_map, method_map,
-                                         tcx, e, (is_const, v)); }
+          expr_paren(e) => { check_expr(v, sess, def_map, method_map,
+                                        tcx, e, is_const); }
           expr_vstore(_, expr_vstore_slice) |
           expr_vec(_, m_imm) |
           expr_addr_of(m_imm, _) |
@@ -192,7 +216,7 @@ pub fn check_expr(sess: Session,
       }
       _ => ()
     }
-    oldvisit::visit_expr(e, (is_const, v));
+    visit::walk_expr(v, e, is_const);
 }
 
 #[deriving(Clone)]
@@ -204,6 +228,8 @@ struct env {
     idstack: @mut ~[NodeId]
 }
 
+struct CheckItemRecursionVisitor;
+
 // Make sure a const item doesn't recursively refer to itself
 // FIXME: Should use the dependency graph when it's available (#1356)
 pub fn check_item_recursion(sess: Session,
@@ -218,36 +244,34 @@ pub fn check_item_recursion(sess: Session,
         idstack: @mut ~[]
     };
 
-    let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
-        visit_item: visit_item,
-        visit_expr: visit_expr,
-        .. *oldvisit::default_visitor()
-    });
-    (visitor.visit_item)(it, (env, visitor));
+    let mut visitor = CheckItemRecursionVisitor;
+    visitor.visit_item(it, env);
+}
 
-    fn visit_item(it: @item, (env, v): (env, oldvisit::vt<env>)) {
+impl Visitor<env> for CheckItemRecursionVisitor {
+    fn visit_item(&mut self, it: @item, env: env) {
         if env.idstack.iter().any(|x| x == &(it.id)) {
             env.sess.span_fatal(env.root_it.span, "recursive constant");
         }
         env.idstack.push(it.id);
-        oldvisit::visit_item(it, (env, v));
+        visit::walk_item(self, it, env);
         env.idstack.pop();
     }
 
-    fn visit_expr(e: @expr, (env, v): (env, oldvisit::vt<env>)) {
+    fn visit_expr(&mut self, e: @expr, env: env) {
         match e.node {
             expr_path(*) => match env.def_map.find(&e.id) {
                 Some(&def_static(def_id, _)) if ast_util::is_local(def_id) =>
                     match env.ast_map.get_copy(&def_id.node) {
                         ast_map::node_item(it, _) => {
-                            (v.visit_item)(it, (env, v));
+                            self.visit_item(it, env);
                         }
                         _ => fail!("const not bound to an item")
                     },
                 _ => ()
             },
             _ => ()
         }
-        oldvisit::visit_expr(e, (env, v));
+        visit::walk_expr(self, e, env);
     }
 }

src/librustc/middle/check_loop.rs

@@ -12,58 +12,64 @@
 use middle::ty;
 
 use syntax::ast::*;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
 
 #[deriving(Clone)]
 pub struct Context {
     in_loop: bool,
     can_ret: bool
 }
 
+struct CheckLoopVisitor {
+    tcx: ty::ctxt,
+}
+
 pub fn check_crate(tcx: ty::ctxt, crate: &Crate) {
-    oldvisit::visit_crate(crate,
-                          (Context { in_loop: false, can_ret: true },
-                          oldvisit::mk_vt(@oldvisit::Visitor {
-        visit_item: |i, (_cx, v)| {
-            oldvisit::visit_item(i, (Context {
+    visit::walk_crate(&mut CheckLoopVisitor { tcx: tcx },
+                      crate,
+                      Context { in_loop: false, can_ret: true });
+}
+
+impl Visitor<Context> for CheckLoopVisitor {
+    fn visit_item(&mut self, i:@item, _cx:Context) {
+        visit::walk_item(self, i, Context {
                                     in_loop: false,
                                     can_ret: true
-                                 }, v));
-        },
-        visit_expr: |e: @expr, (cx, v): (Context, oldvisit::vt<Context>)| {
+                                  });
+    }
+
+    fn visit_expr(&mut self, e:@expr, cx:Context) {
+
             match e.node {
               expr_while(e, ref b) => {
-                (v.visit_expr)(e, (cx, v));
-                (v.visit_block)(b, (Context { in_loop: true,.. cx }, v));
+                self.visit_expr(e, cx);
+                self.visit_block(b, Context { in_loop: true,.. cx });
               }
               expr_loop(ref b, _) => {
-                (v.visit_block)(b, (Context { in_loop: true,.. cx }, v));
+                self.visit_block(b, Context { in_loop: true,.. cx });
               }
               expr_fn_block(_, ref b) => {
-                (v.visit_block)(b, (Context {
-                                         in_loop: false,
-                                         can_ret: false
-                                      }, v));
+                self.visit_block(b, Context { in_loop: false, can_ret: false });
               }
               expr_break(_) => {
                 if !cx.in_loop {
-                    tcx.sess.span_err(e.span, "`break` outside of loop");
+                    self.tcx.sess.span_err(e.span, "`break` outside of loop");
                 }
               }
               expr_again(_) => {
                 if !cx.in_loop {
-                    tcx.sess.span_err(e.span, "`loop` outside of loop");
+                    self.tcx.sess.span_err(e.span, "`loop` outside of loop");
                 }
               }
               expr_ret(oe) => {
                 if !cx.can_ret {
-                    tcx.sess.span_err(e.span, "`return` in block function");
+                    self.tcx.sess.span_err(e.span, "`return` in block function");
                 }
-                oldvisit::visit_expr_opt(oe, (cx, v));
+                visit::walk_expr_opt(self, oe, cx);
               }
-              _ => oldvisit::visit_expr(e, (cx, v))
+              _ => visit::walk_expr(self, e, cx)
             }
-        },
-        .. *oldvisit::default_visitor()
-    })));
+
+    }
 }

src/librustc/middle/check_match.rs

@@ -25,35 +25,50 @@ use extra::sort;
 use syntax::ast::*;
 use syntax::ast_util::{unguarded_pat, walk_pat};
 use syntax::codemap::{span, dummy_sp, spanned};
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::{Visitor,fn_kind};
 
 pub struct MatchCheckCtxt {
     tcx: ty::ctxt,
     method_map: method_map,
     moves_map: moves::MovesMap
 }
 
+struct CheckMatchVisitor {
+    cx: @MatchCheckCtxt
+}
+
+impl Visitor<()> for CheckMatchVisitor {
+    fn visit_expr(&mut self, ex:@expr, e:()) {
+        check_expr(self, self.cx, ex, e);
+    }
+    fn visit_local(&mut self, l:@Local, e:()) {
+        check_local(self, self.cx, l, e);
+    }
+    fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:&Block, s:span, n:NodeId, e:()) {
+        check_fn(self, self.cx, fk, fd, b, s, n, e);
+    }
+}
+
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: method_map,
                    moves_map: moves::MovesMap,
                    crate: &Crate) {
     let cx = @MatchCheckCtxt {tcx: tcx,
                               method_map: method_map,
                               moves_map: moves_map};
-    oldvisit::visit_crate(crate, ((), oldvisit::mk_vt(@oldvisit::Visitor {
-        visit_expr: |a,b| check_expr(cx, a, b),
-        visit_local: |a,b| check_local(cx, a, b),
-        visit_fn: |kind, decl, body, sp, id, (e, v)|
-            check_fn(cx, kind, decl, body, sp, id, (e, v)),
-        .. *oldvisit::default_visitor::<()>()
-    })));
+    let mut v = CheckMatchVisitor { cx: cx };
+
+    visit::walk_crate(&mut v, crate, ());
+
     tcx.sess.abort_if_errors();
 }
 
-pub fn check_expr(cx: @MatchCheckCtxt,
+pub fn check_expr(v: &mut CheckMatchVisitor,
+                  cx: @MatchCheckCtxt,
                   ex: @expr,
-                  (s, v): ((), oldvisit::vt<()>)) {
-    oldvisit::visit_expr(ex, (s, v));
+                  s: ()) {
+    visit::walk_expr(v, ex, s);
     match ex.node {
       expr_match(scrut, ref arms) => {
         // First, check legality of move bindings.
@@ -787,10 +802,11 @@ pub fn default(cx: &MatchCheckCtxt, r: &[@pat]) -> Option<~[@pat]> {
     else { None }
 }
 
-pub fn check_local(cx: &MatchCheckCtxt,
+pub fn check_local(v: &mut CheckMatchVisitor,
+                   cx: &MatchCheckCtxt,
                    loc: @Local,
-                   (s, v): ((), oldvisit::vt<()>)) {
-    oldvisit::visit_local(loc, (s, v));
+                   s: ()) {
+    visit::walk_local(v, loc, s);
     if is_refutable(cx, loc.pat) {
         cx.tcx.sess.span_err(loc.pat.span,
                              "refutable pattern in local binding");
@@ -800,15 +816,15 @@ pub fn check_local(cx: &MatchCheckCtxt,
     check_legality_of_move_bindings(cx, false, [ loc.pat ]);
 }
 
-pub fn check_fn(cx: &MatchCheckCtxt,
-                kind: &oldvisit::fn_kind,
+pub fn check_fn(v: &mut CheckMatchVisitor,
+                cx: &MatchCheckCtxt,
+                kind: &visit::fn_kind,
                 decl: &fn_decl,
                 body: &Block,
                 sp: span,
                 id: NodeId,
-                (s, v): ((),
-                         oldvisit::vt<()>)) {
-    oldvisit::visit_fn(kind, decl, body, sp, id, (s, v));
+                s: ()) {
+    visit::walk_fn(v, kind, decl, body, sp, id, s);
     for input in decl.inputs.iter() {
         if is_refutable(cx, input.pat) {
             cx.tcx.sess.span_err(input.pat.span,