---

yaml
---
r: 85371
b: refs/heads/dist-snap
c: b97cc95
h: refs/heads/master
i:
  85369: a3b2d57
  85367: 305e813
v: v3

Author: pnkfelix

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 0d85928e37dec4795cf288e9f0bbe23d7a100b7a
+refs/heads/dist-snap: b97cc955c2b2d9494607434352e0898ee0eca0b8
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/borrowck/mod.rs

@@ -26,9 +26,11 @@ use std::ops::{BitOr, BitAnd};
 use std::result::{Result};
 use syntax::ast;
 use syntax::ast_map;
-use syntax::oldvisit;
 use syntax::codemap::span;
 use syntax::parse::token;
+use syntax::visit;
+use syntax::visit::{Visitor,fn_kind};
+use syntax::ast::{fn_decl,Block,NodeId};
 
 macro_rules! if_ok(
     ($inp: expr) => (
@@ -59,6 +61,15 @@ impl Clone for LoanDataFlowOperator {
 
 pub type LoanDataFlow = DataFlowContext<LoanDataFlowOperator>;
 
+struct BorrowckVisitor;
+
+impl Visitor<@BorrowckCtxt> for BorrowckVisitor {
+    fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl,
+                b:&Block, s:span, n:NodeId, e:@BorrowckCtxt) {
+        borrowck_fn(self, fk, fd, b, s, n, e);
+    }
+}
+
 pub fn check_crate(
     tcx: ty::ctxt,
     method_map: typeck::method_map,
@@ -86,9 +97,8 @@ pub fn check_crate(
         }
     };
 
-    let v = oldvisit::mk_vt(@oldvisit::Visitor {visit_fn: borrowck_fn,
-                                          ..*oldvisit::default_visitor()});
-    oldvisit::visit_crate(crate, (bccx, v));
+    let mut v = BorrowckVisitor;
+    visit::walk_crate(&mut v, crate, bccx);
 
     if tcx.sess.borrowck_stats() {
         io::println("--- borrowck stats ---");
@@ -113,21 +123,21 @@ pub fn check_crate(
     }
 }
 
-fn borrowck_fn(fk: &oldvisit::fn_kind,
+fn borrowck_fn(v: &mut BorrowckVisitor,
+               fk: &visit::fn_kind,
                decl: &ast::fn_decl,
                body: &ast::Block,
                sp: span,
                id: ast::NodeId,
-               (this, v): (@BorrowckCtxt,
-                           oldvisit::vt<@BorrowckCtxt>)) {
+               this: @BorrowckCtxt) {
     match fk {
-        &oldvisit::fk_anon(*) |
-        &oldvisit::fk_fn_block(*) => {
+        &visit::fk_anon(*) |
+        &visit::fk_fn_block(*) => {
             // Closures are checked as part of their containing fn item.
         }
 
-        &oldvisit::fk_item_fn(*) |
-        &oldvisit::fk_method(*) => {
+        &visit::fk_item_fn(*) |
+        &visit::fk_method(*) => {
             debug!("borrowck_fn(id=%?)", id);
 
             // Check the body of fn items.
@@ -156,7 +166,7 @@ fn borrowck_fn(fk: &oldvisit::fn_kind,
         }
     }
 
-    oldvisit::visit_fn(fk, decl, body, sp, id, (this, v));
+    visit::walk_fn(v, fk, decl, body, sp, id, this);
 }
 
 // ----------------------------------------------------------------------

branches/dist-snap/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, _) |
@@ -191,7 +215,7 @@ pub fn check_expr(sess: Session,
       }
       _ => ()
     }
-    oldvisit::visit_expr(e, (is_const, v));
+    visit::walk_expr(v, e, is_const);
 }
 
 #[deriving(Clone)]
@@ -203,6 +227,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,
@@ -217,36 +243,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);
     }
 }

branches/dist-snap/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()
-    })));
+
+    }
 }