Auto merge of #29903 - nikomatsakis:incr-comp-ool-items, r=nrc,mw

This PR moves items into a separate map stored in the krate, rather than storing them inline in the HIR. The HIR visitor is also modified to skip visiting nested items by default. The goal here is to ensure that if you get access to the HIR for one item, you don't automatically get access to a bunch of other items, for better dependency tracking.

r? @nrc
cc @eddyb

Author: bors

src/librustc/front/map/blocks.rs

@@ -29,7 +29,7 @@ use rustc_front::hir::{Block, FnDecl};
 use syntax::ast::{Name, NodeId};
 use rustc_front::hir as ast;
 use syntax::codemap::Span;
-use rustc_front::visit::FnKind;
+use rustc_front::intravisit::FnKind;
 
 /// An FnLikeNode is a Node that is like a fn, in that it has a decl
 /// and a body (as well as a NodeId, a span, etc).

src/librustc/front/map/collector.rs

@@ -13,7 +13,7 @@ use super::MapEntry::*;
 
 use rustc_front::hir::*;
 use rustc_front::util;
-use rustc_front::visit::{self, Visitor};
+use rustc_front::intravisit::{self, Visitor};
 use middle::def_id::{CRATE_DEF_INDEX, DefIndex};
 use std::iter::repeat;
 use syntax::ast::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
@@ -22,14 +22,16 @@ use syntax::codemap::Span;
 /// A Visitor that walks over an AST and collects Node's into an AST
 /// Map.
 pub struct NodeCollector<'ast> {
+    pub krate: &'ast Crate,
     pub map: Vec<MapEntry<'ast>>,
     pub definitions: Definitions,
     pub parent_node: NodeId,
 }
 
 impl<'ast> NodeCollector<'ast> {
-    pub fn root() -> NodeCollector<'ast> {
+    pub fn root(krate: &'ast Crate) -> NodeCollector<'ast> {
         let mut collector = NodeCollector {
+            krate: krate,
             map: vec![],
             definitions: Definitions::new(),
             parent_node: CRATE_NODE_ID,
@@ -44,13 +46,15 @@ impl<'ast> NodeCollector<'ast> {
         collector
     }
 
-    pub fn extend(parent: &'ast InlinedParent,
+    pub fn extend(krate: &'ast Crate,
+                  parent: &'ast InlinedParent,
                   parent_node: NodeId,
                   parent_def_path: DefPath,
                   map: Vec<MapEntry<'ast>>,
                   definitions: Definitions)
                   -> NodeCollector<'ast> {
         let mut collector = NodeCollector {
+            krate: krate,
             map: map,
             parent_node: parent_node,
             definitions: definitions,
@@ -107,6 +111,13 @@ impl<'ast> NodeCollector<'ast> {
 }
 
 impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
+    /// Because we want to track parent items and so forth, enable
+    /// deep walking so that we walk nested items in the context of
+    /// their outer items.
+    fn visit_nested_item(&mut self, item: ItemId) {
+        self.visit_item(self.krate.item(item.id))
+    }
+
     fn visit_item(&mut self, i: &'ast Item) {
         // Pick the def data. This need not be unique, but the more
         // information we encapsulate into
@@ -173,7 +184,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             }
             _ => {}
         }
-        visit::walk_item(self, i);
+        intravisit::walk_item(self, i);
         self.parent_node = parent_node;
     }
 
@@ -184,7 +195,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
 
         let parent_node = self.parent_node;
         self.parent_node = foreign_item.id;
-        visit::walk_foreign_item(self, foreign_item);
+        intravisit::walk_foreign_item(self, foreign_item);
         self.parent_node = parent_node;
     }
 
@@ -195,7 +206,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
                             DefPathData::TypeParam(ty_param.name));
         }
 
-        visit::walk_generics(self, generics);
+        intravisit::walk_generics(self, generics);
     }
 
     fn visit_trait_item(&mut self, ti: &'ast TraitItem) {
@@ -217,7 +228,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             _ => { }
         }
 
-        visit::walk_trait_item(self, ti);
+        intravisit::walk_trait_item(self, ti);
 
         self.parent_node = parent_node;
     }
@@ -240,7 +251,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             _ => { }
         }
 
-        visit::walk_impl_item(self, ii);
+        intravisit::walk_impl_item(self, ii);
 
         self.parent_node = parent_node;
     }
@@ -259,7 +270,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
 
         let parent_node = self.parent_node;
         self.parent_node = pat.id;
-        visit::walk_pat(self, pat);
+        intravisit::walk_pat(self, pat);
         self.parent_node = parent_node;
     }
 
@@ -273,7 +284,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
 
         let parent_node = self.parent_node;
         self.parent_node = expr.id;
-        visit::walk_expr(self, expr);
+        intravisit::walk_expr(self, expr);
         self.parent_node = parent_node;
     }
 
@@ -282,21 +293,21 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
         self.insert(id, NodeStmt(stmt));
         let parent_node = self.parent_node;
         self.parent_node = id;
-        visit::walk_stmt(self, stmt);
+        intravisit::walk_stmt(self, stmt);
         self.parent_node = parent_node;
     }
 
-    fn visit_fn(&mut self, fk: visit::FnKind<'ast>, fd: &'ast FnDecl,
+    fn visit_fn(&mut self, fk: intravisit::FnKind<'ast>, fd: &'ast FnDecl,
                 b: &'ast Block, s: Span, id: NodeId) {
         assert_eq!(self.parent_node, id);
-        visit::walk_fn(self, fk, fd, b, s);
+        intravisit::walk_fn(self, fk, fd, b, s);
     }
 
     fn visit_block(&mut self, block: &'ast Block) {
         self.insert(block.id, NodeBlock(block));
         let parent_node = self.parent_node;
         self.parent_node = block.id;
-        visit::walk_block(self, block);
+        intravisit::walk_block(self, block);
         self.parent_node = parent_node;
     }
 

src/librustc/front/map/mod.rs

@@ -25,7 +25,7 @@ use syntax::parse::token;
 
 use rustc_front::hir::*;
 use rustc_front::fold::Folder;
-use rustc_front::visit;
+use rustc_front::intravisit;
 use rustc_front::print::pprust;
 
 use arena::TypedArena;
@@ -809,9 +809,11 @@ impl<F: FoldOps> Folder for IdAndSpanUpdater<F> {
 }
 
 pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> {
-    let mut collector = NodeCollector::root();
-    visit::walk_crate(&mut collector, &forest.krate);
-    let NodeCollector { map, definitions, .. } = collector;
+    let (map, definitions) = {
+        let mut collector = NodeCollector::root(&forest.krate);
+        intravisit::walk_crate(&mut collector, &forest.krate);
+        (collector.map, collector.definitions)
+    };
 
     if log_enabled!(::log::DEBUG) {
         // This only makes sense for ordered stores; note the
@@ -847,7 +849,7 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
                                           -> &'ast InlinedItem {
     let mut fld = IdAndSpanUpdater { fold_ops: fold_ops };
     let ii = match ii {
-        II::Item(i) => II::Item(fld.fold_item(i)),
+        II::Item(i) => II::Item(i.map(|i| fld.fold_item(i))),
         II::TraitItem(d, ti) => {
             II::TraitItem(fld.fold_ops.new_def_id(d),
                           fld.fold_trait_item(ti))
@@ -867,6 +869,7 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
     let ii_parent_id = fld.new_id(DUMMY_NODE_ID);
     let mut collector =
         NodeCollector::extend(
+            map.krate(),
             ii_parent,
             ii_parent_id,
             def_path,

src/librustc/lint/context.rs

@@ -44,7 +44,7 @@ use syntax::parse::token::InternedString;
 use syntax::ast;
 use rustc_front::hir;
 use rustc_front::util;
-use rustc_front::visit as hir_visit;
+use rustc_front::intravisit as hir_visit;
 use syntax::visit as ast_visit;
 use syntax::diagnostic;
 
@@ -555,7 +555,6 @@ impl<'a> EarlyContext<'a> {
     {
         let mut v = ast_util::IdVisitor {
             operation: self,
-            pass_through_items: false,
             visited_outermost: false,
         };
         f(&mut v);
@@ -583,11 +582,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
     fn visit_ids<F>(&mut self, f: F)
         where F: FnOnce(&mut util::IdVisitor<LateContext>)
     {
-        let mut v = util::IdVisitor {
-            operation: self,
-            pass_through_items: false,
-            visited_outermost: false,
-        };
+        let mut v = util::IdVisitor::new(self);
         f(&mut v);
     }
 }
@@ -611,10 +606,12 @@ impl<'a, 'tcx> LintContext for LateContext<'a, 'tcx> {
     }
 
     fn enter_attrs(&mut self, attrs: &[ast::Attribute]) {
+        debug!("late context: enter_attrs({:?})", attrs);
         run_lints!(self, enter_lint_attrs, late_passes, attrs);
     }
 
     fn exit_attrs(&mut self, attrs: &[ast::Attribute]) {
+        debug!("late context: exit_attrs({:?})", attrs);
         run_lints!(self, exit_lint_attrs, late_passes, attrs);
     }
 }
@@ -638,15 +635,24 @@ impl<'a> LintContext for EarlyContext<'a> {
     }
 
     fn enter_attrs(&mut self, attrs: &[ast::Attribute]) {
+        debug!("early context: exit_attrs({:?})", attrs);
         run_lints!(self, enter_lint_attrs, early_passes, attrs);
     }
 
     fn exit_attrs(&mut self, attrs: &[ast::Attribute]) {
+        debug!("early context: exit_attrs({:?})", attrs);
         run_lints!(self, exit_lint_attrs, early_passes, attrs);
     }
 }
 
 impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
+    /// Because lints are scoped lexically, we want to walk nested
+    /// items in the context of the outer item, so enable
+    /// deep-walking.
+    fn visit_nested_item(&mut self, item: hir::ItemId) {
+        self.visit_item(self.tcx.map.expect_item(item.id))
+    }
+
     fn visit_item(&mut self, it: &hir::Item) {
         self.with_lint_attrs(&it.attrs, |cx| {
             run_lints!(cx, check_item, late_passes, it);
@@ -952,6 +958,7 @@ impl<'a, 'tcx> IdVisitingOperation for LateContext<'a, 'tcx> {
         match self.sess().lints.borrow_mut().remove(&id) {
             None => {}
             Some(lints) => {
+                debug!("LateContext::visit_id: id={:?} lints={:?}", id, lints);
                 for (lint_id, span, msg) in lints {
                     self.span_lint(lint_id.lint, span, &msg[..])
                 }
@@ -1008,16 +1015,14 @@ impl LateLintPass for GatherNodeLevels {
 ///
 /// Consumes the `lint_store` field of the `Session`.
 pub fn check_crate(tcx: &ty::ctxt,
-                   krate: &hir::Crate,
                    exported_items: &ExportedItems) {
-
+    let krate = tcx.map.krate();
     let mut cx = LateContext::new(tcx, krate, exported_items);
 
     // Visit the whole crate.
     cx.with_lint_attrs(&krate.attrs, |cx| {
         cx.visit_id(ast::CRATE_NODE_ID);
         cx.visit_ids(|v| {
-            v.visited_outermost = true;
             hir_visit::walk_crate(v, krate);
         });
 

src/librustc/lint/mod.rs

@@ -34,7 +34,7 @@ pub use self::LintSource::*;
 use std::hash;
 use std::ascii::AsciiExt;
 use syntax::codemap::Span;
-use rustc_front::visit::FnKind;
+use rustc_front::intravisit::FnKind;
 use syntax::visit as ast_visit;
 use syntax::ast;
 use rustc_front::hir;
@@ -218,7 +218,7 @@ pub type EarlyLintPassObject = Box<EarlyLintPass + 'static>;
 pub type LateLintPassObject = Box<LateLintPass + 'static>;
 
 /// Identifies a lint known to the compiler.
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub struct LintId {
     // Identity is based on pointer equality of this field.
     lint: &'static Lint,

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) {