rustc: store ty::Tables separately for each body (except closures').

rust-lang · Jan 6, 2017 · cde0a7e · cde0a7e
1 parent 85a4a19
commit cde0a7e
Show file tree

Hide file tree

Showing 17 changed files with 220 additions and 474 deletions.
diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs
@@ -113,6 +113,7 @@ pub enum DepNode<D: Clone + Debug> {
     SizedConstraint(D),
     AssociatedItemDefIds(D),
     InherentImpls(D),
+    Tables(D),
 
     // The set of impls for a given trait. Ultimately, it would be
     // nice to get more fine-grained here (e.g., to include a
@@ -162,6 +163,7 @@ impl<D: Clone + Debug> DepNode<D> {
             ItemSignature,
             AssociatedItemDefIds,
             InherentImpls,
+            Tables,
             TraitImpls,
             ReprHints,
         }
@@ -230,6 +232,7 @@ impl<D: Clone + Debug> DepNode<D> {
             SizedConstraint(ref d) => op(d).map(SizedConstraint),
             AssociatedItemDefIds(ref d) => op(d).map(AssociatedItemDefIds),
             InherentImpls(ref d) => op(d).map(InherentImpls),
+            Tables(ref d) => op(d).map(Tables),
             TraitImpls(ref d) => op(d).map(TraitImpls),
             TraitItems(ref d) => op(d).map(TraitItems),
             ReprHints(ref d) => op(d).map(ReprHints),

diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs
@@ -23,10 +23,6 @@ pub struct NodeCollector<'ast> {
     pub(super) map: Vec<MapEntry<'ast>>,
     /// The parent of this node
     pub parent_node: NodeId,
-    /// If true, completely ignore nested items. We set this when loading
-    /// HIR from metadata, since in that case we only want the HIR for
-    /// one specific item (and not the ones nested inside of it).
-    pub ignore_nested_items: bool
 }
 
 impl<'ast> NodeCollector<'ast> {
@@ -35,30 +31,12 @@ impl<'ast> NodeCollector<'ast> {
             krate: krate,
             map: vec![],
             parent_node: CRATE_NODE_ID,
-            ignore_nested_items: false
         };
         collector.insert_entry(CRATE_NODE_ID, RootCrate);
 
         collector
     }
 
-    pub(super) fn extend(krate: &'ast Crate,
-                         parent: &'ast InlinedItem,
-                         parent_node: NodeId,
-                         map: Vec<MapEntry<'ast>>)
-                         -> NodeCollector<'ast> {
-        let mut collector = NodeCollector {
-            krate: krate,
-            map: map,
-            parent_node: parent_node,
-            ignore_nested_items: true
-        };
-
-        collector.insert_entry(parent_node, RootInlinedParent(parent));
-
-        collector
-    }
-
     fn insert_entry(&mut self, id: NodeId, entry: MapEntry<'ast>) {
         debug!("ast_map: {:?} => {:?}", id, entry);
         let len = self.map.len();
@@ -92,27 +70,19 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
 
     fn visit_nested_item(&mut self, item: ItemId) {
         debug!("visit_nested_item: {:?}", item);
-        if !self.ignore_nested_items {
-            self.visit_item(self.krate.item(item.id))
-        }
+        self.visit_item(self.krate.item(item.id));
     }
 
     fn visit_nested_trait_item(&mut self, item_id: TraitItemId) {
-        if !self.ignore_nested_items {
-            self.visit_trait_item(self.krate.trait_item(item_id))
-        }
+        self.visit_trait_item(self.krate.trait_item(item_id));
     }
 
     fn visit_nested_impl_item(&mut self, item_id: ImplItemId) {
-        if !self.ignore_nested_items {
-            self.visit_impl_item(self.krate.impl_item(item_id))
-        }
+        self.visit_impl_item(self.krate.impl_item(item_id));
     }
 
     fn visit_nested_body(&mut self, id: BodyId) {
-        if !self.ignore_nested_items {
-            self.visit_body(self.krate.body(id))
-        }
+        self.visit_body(self.krate.body(id));
     }
 
     fn visit_item(&mut self, i: &'ast Item) {