Port a bunch of code new-visitor; all of these ports were

straightforward uses of `visit_all_items`. In some cases I had to remove
empty `visit_item` calls that were just to suppress visiting nested
items.

src/librustc/metadata/creader.rs

@@ -37,7 +37,7 @@ use syntax::attr;
 use syntax::attr::AttrMetaMethods;
 use syntax::parse::token::InternedString;
 use syntax::util::small_vector::SmallVector;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
 use rustc_front::hir;
 use log;
 
@@ -53,10 +53,9 @@ pub struct CrateReader<'a> {
     foreign_item_map: FnvHashMap<String, Vec<ast::NodeId>>,
 }
 
-impl<'a, 'b, 'v> visit::Visitor<'v> for LocalCrateReader<'a, 'b> {
-    fn visit_item(&mut self, a: &hir::Item) {
+impl<'a, 'b, 'hir> Visitor<'hir> for LocalCrateReader<'a, 'b> {
+    fn visit_item(&mut self, a: &'hir hir::Item) {
         self.process_item(a);
-        visit::walk_item(self, a);
     }
 }
 
@@ -716,7 +715,7 @@ impl<'a, 'b> LocalCrateReader<'a, 'b> {
     // etc.
     pub fn read_crates(&mut self, krate: &hir::Crate) {
         self.process_crate(krate);
-        visit::walk_crate(self, krate);
+        krate.visit_all_items(self);
         self.creader.inject_allocator_crate();
 
         if log_enabled!(log::INFO) {

src/librustc/metadata/encoder.rs

@@ -46,8 +46,8 @@ use syntax;
 use rbml::writer::Encoder;
 
 use rustc_front::hir;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
+use rustc_front::intravisit;
 use front::map::{LinkedPath, PathElem, PathElems};
 use front::map as ast_map;
 
@@ -431,11 +431,12 @@ fn encode_info_for_mod(ecx: &EncodeContext,
     debug!("(encoding info for module) encoding info for module ID {}", id);
 
     // Encode info about all the module children.
-    for item in &md.items {
+    for item_id in &md.item_ids {
         rbml_w.wr_tagged_u64(tag_mod_child,
-                             def_to_u64(ecx.tcx.map.local_def_id(item.id)));
+                             def_to_u64(ecx.tcx.map.local_def_id(item_id.id)));
 
-        each_auxiliary_node_id(&**item, |auxiliary_node_id| {
+        let item = ecx.tcx.map.expect_item(item_id.id);
+        each_auxiliary_node_id(item, |auxiliary_node_id| {
             rbml_w.wr_tagged_u64(tag_mod_child,
                                  def_to_u64(ecx.tcx.map.local_def_id(auxiliary_node_id)));
             true
@@ -1468,25 +1469,26 @@ struct EncodeVisitor<'a, 'b:'a, 'c:'a, 'tcx:'c> {
     index: &'a mut CrateIndex<'tcx>,
 }
 
-impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for EncodeVisitor<'a, 'b, 'c, 'tcx> {
-    fn visit_expr(&mut self, ex: &hir::Expr) {
-        visit::walk_expr(self, ex);
+impl<'a, 'b, 'c, 'tcx> Visitor<'tcx> for EncodeVisitor<'a, 'b, 'c, 'tcx> {
+    fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
+        intravisit::walk_expr(self, ex);
         my_visit_expr(ex, self.rbml_w_for_visit_item, self.ecx, self.index);
     }
-    fn visit_item(&mut self, i: &hir::Item) {
-        visit::walk_item(self, i);
+    fn visit_item(&mut self, i: &'tcx hir::Item) {
+        intravisit::walk_item(self, i);
         my_visit_item(i, self.rbml_w_for_visit_item, self.ecx, self.index);
     }
-    fn visit_foreign_item(&mut self, ni: &hir::ForeignItem) {
-        visit::walk_foreign_item(self, ni);
+    fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem) {
+        intravisit::walk_foreign_item(self, ni);
         my_visit_foreign_item(ni, self.rbml_w_for_visit_item, self.ecx, self.index);
     }
 }
 
 fn encode_info_for_items<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
-                                   rbml_w: &mut Encoder,
-                                   krate: &hir::Crate)
+                                   rbml_w: &mut Encoder)
                                    -> CrateIndex<'tcx> {
+    let krate = ecx.tcx.map.krate();
+
     let mut index = CrateIndex {
         items: IndexData::new(ecx.tcx.map.num_local_def_ids()),
         xrefs: FnvHashMap()
@@ -1503,11 +1505,11 @@ fn encode_info_for_items<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
                         syntax::parse::token::intern(&ecx.link_meta.crate_name),
                         hir::Public);
 
-    visit::walk_crate(&mut EncodeVisitor {
+    krate.visit_all_items(&mut EncodeVisitor {
         index: &mut index,
         ecx: ecx,
         rbml_w_for_visit_item: &mut *rbml_w,
-    }, krate);
+    });
 
     rbml_w.end_tag();
     index
@@ -1735,7 +1737,7 @@ fn encode_struct_field_attrs(ecx: &EncodeContext,
     }
 
     rbml_w.start_tag(tag_struct_fields);
-    visit::walk_crate(&mut StructFieldVisitor { ecx: ecx, rbml_w: rbml_w }, krate);
+    krate.visit_all_items(&mut StructFieldVisitor { ecx: ecx, rbml_w: rbml_w });
     rbml_w.end_tag();
 }
 
@@ -1756,7 +1758,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'tcx> {
                     .push(impl_id);
             }
         }
-        visit::walk_item(self, item);
     }
 }
 
@@ -1768,7 +1769,7 @@ fn encode_impls<'a>(ecx: &'a EncodeContext,
         tcx: ecx.tcx,
         impls: FnvHashMap()
     };
-    visit::walk_crate(&mut visitor, krate);
+    krate.visit_all_items(&mut visitor);
 
     rbml_w.start_tag(tag_impls);
     for (trait_, trait_impls) in visitor.impls {
@@ -1787,11 +1788,12 @@ fn encode_misc_info(ecx: &EncodeContext,
                     rbml_w: &mut Encoder) {
     rbml_w.start_tag(tag_misc_info);
     rbml_w.start_tag(tag_misc_info_crate_items);
-    for item in &krate.module.items {
+    for item_id in &krate.module.item_ids {
         rbml_w.wr_tagged_u64(tag_mod_child,
-                             def_to_u64(ecx.tcx.map.local_def_id(item.id)));
+                             def_to_u64(ecx.tcx.map.local_def_id(item_id.id)));
 
-        each_auxiliary_node_id(&**item, |auxiliary_node_id| {
+        let item = ecx.tcx.map.expect_item(item_id.id);
+        each_auxiliary_node_id(item, |auxiliary_node_id| {
             rbml_w.wr_tagged_u64(tag_mod_child,
                                  def_to_u64(ecx.tcx.map.local_def_id(auxiliary_node_id)));
             true
@@ -2022,7 +2024,7 @@ fn encode_metadata_inner(wr: &mut Cursor<Vec<u8>>,
     // Encode and index the items.
     rbml_w.start_tag(tag_items);
     i = rbml_w.writer.seek(SeekFrom::Current(0)).unwrap();
-    let index = encode_info_for_items(&ecx, &mut rbml_w, krate);
+    let index = encode_info_for_items(&ecx, &mut rbml_w);
     stats.item_bytes = rbml_w.writer.seek(SeekFrom::Current(0)).unwrap() - i;
     rbml_w.end_tag();
 

src/librustc/metadata/inline.rs

@@ -13,7 +13,7 @@ use rustc_front::hir;
 use rustc_front::util::IdVisitor;
 use syntax::ast_util::{IdRange, IdRangeComputingVisitor, IdVisitingOperation};
 use syntax::ptr::P;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::Visitor;
 use self::InlinedItem::*;
 
 /// The data we save and restore about an inlined item or method.  This is not

src/librustc/middle/astencode.rs

@@ -389,7 +389,7 @@ fn simplify_ast(ii: InlinedItemRef) -> InlinedItem {
     match ii {
         // HACK we're not dropping items.
         InlinedItemRef::Item(i) => {
-            InlinedItem::Item(fold::noop_fold_item(P(i.clone()), &mut fld))
+            InlinedItem::Item(P(fold::noop_fold_item(i.clone(), &mut fld)))
         }
         InlinedItemRef::TraitItem(d, ti) => {
             InlinedItem::TraitItem(d, fold::noop_fold_trait_item(P(ti.clone()), &mut fld))

src/librustc/middle/check_const.rs

@@ -41,7 +41,7 @@ use rustc_front::hir;
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::feature_gate::UnstableFeatures;
-use rustc_front::visit::{self, FnKind, Visitor};
+use rustc_front::intravisit::{self, FnKind, Visitor};
 
 use std::collections::hash_map::Entry;
 use std::cmp::Ordering;
@@ -81,7 +81,7 @@ bitflags! {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 enum Mode {
     Const,
     ConstFn,
@@ -190,7 +190,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
 
         let qualif = self.with_mode(mode, |this| {
             this.with_euv(Some(fn_id), |euv| euv.walk_fn(fd, b));
-            visit::walk_fn(this, fk, fd, b, s);
+            intravisit::walk_fn(this, fk, fd, b, s);
             this.qualif
         });
 
@@ -308,6 +308,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
 impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
     fn visit_item(&mut self, i: &hir::Item) {
         debug!("visit_item(item={})", self.tcx.map.node_to_string(i.id));
+        assert_eq!(self.mode, Mode::Var);
         match i.node {
             hir::ItemStatic(_, hir::MutImmutable, ref expr) => {
                 self.check_static_type(&**expr);
@@ -328,7 +329,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
                 }
             }
             _ => {
-                self.with_mode(Mode::Var, |v| visit::walk_item(v, i));
+                intravisit::walk_item(self, i);
             }
         }
     }
@@ -339,10 +340,10 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
                 if let Some(ref expr) = *default {
                     self.global_expr(Mode::Const, &*expr);
                 } else {
-                    visit::walk_trait_item(self, t);
+                    intravisit::walk_trait_item(self, t);
                 }
             }
-            _ => self.with_mode(Mode::Var, |v| visit::walk_trait_item(v, t)),
+            _ => self.with_mode(Mode::Var, |v| intravisit::walk_trait_item(v, t)),
         }
     }
 
@@ -351,7 +352,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
             hir::ImplItemKind::Const(_, ref expr) => {
                 self.global_expr(Mode::Const, &*expr);
             }
-            _ => self.with_mode(Mode::Var, |v| visit::walk_impl_item(v, i)),
+            _ => self.with_mode(Mode::Var, |v| intravisit::walk_impl_item(v, i)),
         }
     }
 
@@ -386,7 +387,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
                     }
                 }
             }
-            _ => visit::walk_pat(self, p)
+            _ => intravisit::walk_pat(self, p)
         }
     }
 
@@ -412,7 +413,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
                            tail expressions", self.msg());
             }
         }
-        visit::walk_block(self, block);
+        intravisit::walk_block(self, block);
     }
 
     fn visit_expr(&mut self, ex: &hir::Expr) {
@@ -464,11 +465,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
                 if let Some(mutbl) = borrow {
                     self.record_borrow(discr.id, mutbl);
                 }
-                visit::walk_expr(self, ex);
+                intravisit::walk_expr(self, ex);
             }
             // Division by zero and overflow checking.
             hir::ExprBinary(op, _, _) => {
-                visit::walk_expr(self, ex);
+                intravisit::walk_expr(self, ex);
                 let div_or_rem = op.node == hir::BiDiv || op.node == hir::BiRem;
                 match node_ty.sty {
                     ty::TyUint(_) | ty::TyInt(_) if div_or_rem => {
@@ -487,7 +488,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
                     _ => {}
                 }
             }
-            _ => visit::walk_expr(self, ex)
+            _ => intravisit::walk_expr(self, ex)
         }
 
         // Handle borrows on (or inside the autorefs of) this expression.
@@ -837,12 +838,12 @@ fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Exp
 }
 
 pub fn check_crate(tcx: &ty::ctxt) {
-    visit::walk_crate(&mut CheckCrateVisitor {
+    tcx.map.krate().visit_all_items(&mut CheckCrateVisitor {
         tcx: tcx,
         mode: Mode::Var,
         qualif: ConstQualif::NOT_CONST,
         rvalue_borrows: NodeMap()
-    }, tcx.map.krate());
+    });
 
     tcx.sess.abort_if_errors();
 }

src/librustc/middle/check_loop.rs

@@ -12,8 +12,7 @@ use self::Context::*;
 use session::Session;
 
 use syntax::codemap::Span;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::{self, Visitor};
 use rustc_front::hir;
 
 #[derive(Clone, Copy, PartialEq)]
@@ -28,12 +27,12 @@ struct CheckLoopVisitor<'a> {
 }
 
 pub fn check_crate(sess: &Session, krate: &hir::Crate) {
-    visit::walk_crate(&mut CheckLoopVisitor { sess: sess, cx: Normal }, krate)
+    krate.visit_all_items(&mut CheckLoopVisitor { sess: sess, cx: Normal });
 }
 
 impl<'a, 'v> Visitor<'v> for CheckLoopVisitor<'a> {
     fn visit_item(&mut self, i: &hir::Item) {
-        self.with_context(Normal, |v| visit::walk_item(v, i));
+        self.with_context(Normal, |v| intravisit::walk_item(v, i));
     }
 
     fn visit_expr(&mut self, e: &hir::Expr) {
@@ -50,7 +49,7 @@ impl<'a, 'v> Visitor<'v> for CheckLoopVisitor<'a> {
             }
             hir::ExprBreak(_) => self.require_loop("break", e.span),
             hir::ExprAgain(_) => self.require_loop("continue", e.span),
-            _ => visit::walk_expr(self, e)
+            _ => intravisit::walk_expr(self, e)
         }
     }
 }

src/librustc/middle/check_match.rs

@@ -33,7 +33,7 @@ use std::iter::{FromIterator, IntoIterator, repeat};
 
 use rustc_front::hir;
 use rustc_front::hir::Pat;
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
 use rustc_front::util as front_util;
 use rustc_back::slice;
 
@@ -155,15 +155,15 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MatchCheckCtxt<'a, 'tcx> {
 }
 
 pub fn check_crate(tcx: &ty::ctxt) {
-    visit::walk_crate(&mut MatchCheckCtxt {
+    tcx.map.krate().visit_all_items(&mut MatchCheckCtxt {
         tcx: tcx,
         param_env: tcx.empty_parameter_environment(),
-    }, tcx.map.krate());
+    });
     tcx.sess.abort_if_errors();
 }
 
 fn check_expr(cx: &mut MatchCheckCtxt, ex: &hir::Expr) {
-    visit::walk_expr(cx, ex);
+    intravisit::walk_expr(cx, ex);
     match ex.node {
         hir::ExprMatch(ref scrut, ref arms, source) => {
             for arm in arms {
@@ -986,7 +986,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
 }
 
 fn check_local(cx: &mut MatchCheckCtxt, loc: &hir::Local) {
-    visit::walk_local(cx, loc);
+    intravisit::walk_local(cx, loc);
 
     let pat = StaticInliner::new(cx.tcx, None).fold_pat(loc.pat.clone());
     check_irrefutable(cx, &pat, false);
@@ -1007,7 +1007,7 @@ fn check_fn(cx: &mut MatchCheckCtxt,
         _ => cx.param_env = ParameterEnvironment::for_item(cx.tcx, fn_id),
     }
 
-    visit::walk_fn(cx, kind, decl, body, sp);
+    intravisit::walk_fn(cx, kind, decl, body, sp);
 
     for input in &decl.inputs {
         check_irrefutable(cx, &input.pat, true);
@@ -1187,10 +1187,10 @@ impl<'a, 'b, 'tcx, 'v> Visitor<'v> for AtBindingPatternVisitor<'a, 'b, 'tcx> {
             hir::PatIdent(_, _, Some(_)) => {
                 let bindings_were_allowed = self.bindings_allowed;
                 self.bindings_allowed = false;
-                visit::walk_pat(self, pat);
+                intravisit::walk_pat(self, pat);
                 self.bindings_allowed = bindings_were_allowed;
             }
-            _ => visit::walk_pat(self, pat),
+            _ => intravisit::walk_pat(self, pat),
         }
     }
 }