Perform indexing during lowering.

Do not access DefId<->HirId maps before they are initialized.

Author: cjgillot

compiler/rustc_middle/src/hir/map/collector.rs renamed to compiler/rustc_ast_lowering/src/index.rs

@@ -1,5 +1,3 @@
-use crate::hir::map::Map;
-use crate::hir::{IndexedHir, OwnerNodes, ParentedNode};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
@@ -12,16 +10,16 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::{Span, DUMMY_SP};
 
 use std::iter::repeat;
+use tracing::debug;
 
 /// A visitor that walks over the HIR and collects `Node`s into a HIR map.
 pub(super) struct NodeCollector<'a, 'hir> {
-    /// The crate
-    krate: &'hir Crate<'hir>,
-
     /// Source map
     source_map: &'a SourceMap,
+    bodies: &'a IndexVec<ItemLocalId, Option<&'hir Body<'hir>>>,
 
-    nodes: OwnerNodes<'hir>,
+    /// Outputs
+    nodes: IndexVec<ItemLocalId, Option<ParentedNode<'hir>>>,
     parenting: FxHashMap<LocalDefId, ItemLocalId>,
 
     /// The parent of this node
@@ -42,28 +40,21 @@ fn insert_vec_map<K: Idx, V: Clone>(map: &mut IndexVec<K, Option<V>>, k: K, v: V
     map[k] = Some(v);
 }
 
-pub(super) fn collect<'a, 'hir: 'a>(
-    sess: &'a Session,
-    krate: &'hir Crate<'hir>,
-    definitions: &'a definitions::Definitions,
-    owner: LocalDefId,
-) -> Option<IndexedHir<'hir>> {
-    let info = krate.owners.get(owner)?.as_ref()?;
-    let item = info.node;
+pub(super) fn index_hir<'hir>(
+    sess: &Session,
+    definitions: &definitions::Definitions,
+    item: hir::OwnerNode<'hir>,
+    bodies: &IndexVec<ItemLocalId, Option<&'hir Body<'hir>>>,
+) -> (IndexVec<ItemLocalId, Option<ParentedNode<'hir>>>, FxHashMap<LocalDefId, ItemLocalId>) {
     let mut nodes = IndexVec::new();
     nodes.push(Some(ParentedNode { parent: ItemLocalId::new(0), node: item.into() }));
     let mut collector = NodeCollector {
-        krate,
         source_map: sess.source_map(),
-        owner,
-        parent_node: ItemLocalId::new(0),
         definitions,
-        nodes: OwnerNodes {
-            hash: info.hash,
-            node_hash: info.node_hash,
-            nodes,
-            bodies: &info.bodies,
-        },
+        owner: item.def_id(),
+        parent_node: ItemLocalId::new(0),
+        nodes,
+        bodies,
         parenting: FxHashMap::default(),
     };
 
@@ -75,7 +66,7 @@ pub(super) fn collect<'a, 'hir: 'a>(
         OwnerNode::ForeignItem(item) => collector.visit_foreign_item(item),
     };
 
-    Some(IndexedHir { nodes: collector.nodes, parenting: collector.parenting })
+    (collector.nodes, collector.parenting)
 }
 
 impl<'a, 'hir> NodeCollector<'a, 'hir> {
@@ -87,17 +78,11 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         // owner of that node.
         if cfg!(debug_assertions) {
             if hir_id.owner != self.owner {
-                let node_str = match self.definitions.opt_hir_id_to_local_def_id(hir_id) {
-                    Some(def_id) => self.definitions.def_path(def_id).to_string_no_crate_verbose(),
-                    None => format!("{:?}", node),
-                };
-
-                span_bug!(
-                    span,
-                    "inconsistent DepNode at `{:?}` for `{}`: \
+                panic!(
+                    "inconsistent DepNode at `{:?}` for `{:?}`: \
                      current_dep_node_owner={} ({:?}), hir_id.owner={} ({:?})",
                     self.source_map.span_to_diagnostic_string(span),
-                    node_str,
+                    node,
                     self.definitions.def_path(self.owner).to_string_no_crate_verbose(),
                     self.owner,
                     self.definitions.def_path(hir_id.owner).to_string_no_crate_verbose(),
@@ -107,7 +92,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         }
 
         insert_vec_map(
-            &mut self.nodes.nodes,
+            &mut self.nodes,
             hir_id.local_id,
             ParentedNode { parent: self.parent_node, node: node },
         );
@@ -122,18 +107,12 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
     }
 
     fn insert_nested(&mut self, item: LocalDefId) {
-        let dk_parent = self.definitions.def_key(item).parent.unwrap();
-        let dk_parent = LocalDefId { local_def_index: dk_parent };
-        let dk_parent = self.definitions.local_def_id_to_hir_id(dk_parent);
-        debug_assert_eq!(dk_parent.owner, self.owner, "Different parents for {:?}", item);
-        if dk_parent.local_id != self.parent_node {
-            self.parenting.insert(item, self.parent_node);
-        }
+        self.parenting.insert(item, self.parent_node);
     }
 }
 
 impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
-    type Map = Map<'hir>;
+    type Map = !;
 
     /// Because we want to track parent items and so forth, enable
     /// deep walking so that we walk nested items in the context of
@@ -161,8 +140,8 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_nested_body(&mut self, id: BodyId) {
-        let body = self.krate.body(id);
         debug_assert_eq!(id.hir_id.owner, self.owner);
+        let body = self.bodies[id.hir_id.local_id].unwrap();
         self.visit_body(body);
     }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -101,7 +101,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let old_len = self.in_scope_lifetimes.len();
 
         let parent_generics =
-            match self.owners[parent_hir_id].as_ref().unwrap().node.expect_item().kind {
+            match self.owners[parent_hir_id].as_ref().unwrap().node().expect_item().kind {
                 hir::ItemKind::Impl(hir::Impl { ref generics, .. })
                 | hir::ItemKind::Trait(_, _, ref generics, ..) => generics.params,
                 _ => &[],

compiler/rustc_ast_lowering/src/lib.rs

@@ -33,6 +33,7 @@
 #![feature(crate_visibility_modifier)]
 #![feature(box_patterns)]
 #![feature(iter_zip)]
+#![feature(never_type)]
 #![recursion_limit = "256"]
 
 use rustc_ast::token::{self, Token};
@@ -78,6 +79,7 @@ macro_rules! arena_vec {
 mod asm;
 mod block;
 mod expr;
+mod index;
 mod item;
 mod pat;
 mod path;
@@ -434,6 +436,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.local_node_ids.push(owner);
 
         let item = f(self);
+        debug_assert_eq!(def_id, item.def_id());
         let info = self.make_owner_info(item);
 
         self.attrs = current_attrs;
@@ -470,8 +473,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
 
         let (hash, node_hash) = self.hash_body(node, &bodies);
+        let (nodes, parenting) =
+            index::index_hir(self.sess, self.resolver.definitions(), node, &bodies);
+        let nodes = hir::OwnerNodes { hash, node_hash, nodes, bodies };
 
-        hir::OwnerInfo { hash, node_hash, node, attrs, bodies, trait_map }
+        hir::OwnerInfo { nodes, parenting, attrs, trait_map }
     }
 
     /// Hash the HIR node twice, one deep and one shallow hash.  This allows to differentiate

compiler/rustc_hir/src/arena.rs

@@ -37,6 +37,7 @@ macro_rules! arena_types {
             [few] llvm_inline_asm: rustc_hir::LlvmInlineAsm<$tcx>,
             [] local: rustc_hir::Local<$tcx>,
             [few] mod_: rustc_hir::Mod<$tcx>,
+            [] owner_info: rustc_hir::OwnerInfo<$tcx>,
             [] param: rustc_hir::Param<$tcx>,
             [] pat: rustc_hir::Pat<$tcx>,
             [] path: rustc_hir::Path<$tcx>,

compiler/rustc_hir/src/hir.rs

@@ -1,5 +1,5 @@
 use crate::def::{CtorKind, DefKind, Res};
-use crate::def_id::{DefId, CRATE_DEF_ID};
+use crate::def_id::DefId;
 crate use crate::hir_id::{HirId, ItemLocalId};
 use crate::LangItem;
 
@@ -663,18 +663,49 @@ pub struct WhereEqPredicate<'hir> {
     pub rhs_ty: &'hir Ty<'hir>,
 }
 
+/// HIR node coupled with its parent's id in the same HIR owner.
+///
+/// The parent is trash when the node is a HIR owner.
+#[derive(Clone, Debug)]
+pub struct ParentedNode<'tcx> {
+    pub parent: ItemLocalId,
+    pub node: Node<'tcx>,
+}
+
+#[derive(Debug)]
+pub struct OwnerNodes<'tcx> {
+    /// Pre-computed hash of the full HIR.
+    pub hash: Fingerprint,
+    /// Pre-computed hash of the top node.
+    pub node_hash: Fingerprint,
+    /// Full HIR for the current owner.
+    // The zeroth node's parent is trash, but is never accessed.
+    pub nodes: IndexVec<ItemLocalId, Option<ParentedNode<'tcx>>>,
+    /// Content of local bodies.
+    pub bodies: IndexVec<ItemLocalId, Option<&'tcx Body<'tcx>>>,
+}
+
 #[derive(Debug)]
 pub struct OwnerInfo<'hir> {
-    pub node: OwnerNode<'hir>,
+    /// Contents of the HIR.
+    pub nodes: OwnerNodes<'hir>,
+    /// Map from each nested owner to its parent's local id.
+    pub parenting: FxHashMap<LocalDefId, ItemLocalId>,
+
     pub attrs: BTreeMap<ItemLocalId, &'hir [Attribute]>,
-    pub bodies: IndexVec<ItemLocalId, Option<&'hir Body<'hir>>>,
     /// Map indicating what traits are in scope for places where this
     /// is relevant; generated by resolve.
     pub trait_map: FxHashMap<ItemLocalId, Box<[TraitCandidate]>>,
-    /// Pre-computed hash of the full HIR.
-    pub hash: Fingerprint,
-    /// Pre-computed hash of the top node.
-    pub node_hash: Fingerprint,
+}
+
+impl<'tcx> OwnerInfo<'tcx> {
+    #[inline]
+    pub fn node(&self) -> OwnerNode<'tcx> {
+        use rustc_index::vec::Idx;
+        let node = self.nodes.nodes[ItemLocalId::new(0)].as_ref().unwrap().node;
+        let node = node.as_owner().unwrap(); // Indexing must ensure it is an OwnerNode.
+        node
+    }
 }
 
 /// The top-level data structure that stores the entire contents of
@@ -688,39 +719,6 @@ pub struct Crate<'hir> {
     pub owners: IndexVec<LocalDefId, Option<OwnerInfo<'hir>>>,
 }
 
-impl Crate<'hir> {
-    pub fn module(&self) -> &'hir Mod<'hir> {
-        let i = self.owners[CRATE_DEF_ID].as_ref().unwrap().node;
-        if let OwnerNode::Crate(m) = i { m } else { panic!() }
-    }
-
-    pub fn item(&self, id: ItemId) -> &'hir Item<'hir> {
-        self.owners[id.def_id].as_ref().unwrap().node.expect_item()
-    }
-
-    pub fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir> {
-        self.owners[id.def_id].as_ref().unwrap().node.expect_trait_item()
-    }
-
-    pub fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir> {
-        self.owners[id.def_id].as_ref().unwrap().node.expect_impl_item()
-    }
-
-    pub fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir> {
-        self.owners[id.def_id].as_ref().unwrap().node.expect_foreign_item()
-    }
-
-    pub fn body(&self, id: BodyId) -> &'hir Body<'hir> {
-        let HirId { owner, local_id } = id.hir_id;
-        self.owners[owner].as_ref().unwrap().bodies[local_id].unwrap()
-    }
-
-    pub fn attrs(&self, id: HirId) -> &'hir [Attribute] {
-        let HirId { owner, local_id } = id;
-        &self.owners[owner].as_ref().unwrap().attrs.get(&local_id).map(|la| *la).unwrap_or(&[])
-    }
-}
-
 /// A block of statements `{ .. }`, which may have a label (in this case the
 /// `targeted_by_break` field will be `true`) and may be `unsafe` by means of
 /// the `rules` being anything but `DefaultBlock`.

compiler/rustc_hir/src/intravisit.rs

@@ -130,6 +130,28 @@ pub trait Map<'hir> {
     fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir>;
 }
 
+// Used when no map is actually available, forcing manual implementation of nested visitors.
+impl Map<'hir> for ! {
+    fn find(&self, _: HirId) -> Option<Node<'hir>> {
+        unreachable!()
+    }
+    fn body(&self, _: BodyId) -> &'hir Body<'hir> {
+        unreachable!()
+    }
+    fn item(&self, _: ItemId) -> &'hir Item<'hir> {
+        unreachable!()
+    }
+    fn trait_item(&self, _: TraitItemId) -> &'hir TraitItem<'hir> {
+        unreachable!()
+    }
+    fn impl_item(&self, _: ImplItemId) -> &'hir ImplItem<'hir> {
+        unreachable!()
+    }
+    fn foreign_item(&self, _: ForeignItemId) -> &'hir ForeignItem<'hir> {
+        unreachable!()
+    }
+}
+
 /// An erased version of `Map<'hir>`, using dynamic dispatch.
 /// NOTE: This type is effectively only usable with `NestedVisitorMap::None`.
 pub struct ErasedMap<'hir>(&'hir dyn Map<'hir>);

compiler/rustc_hir/src/lib.rs

@@ -6,6 +6,7 @@
 #![feature(in_band_lifetimes)]
 #![feature(once_cell)]
 #![feature(min_specialization)]
+#![feature(never_type)]
 #![recursion_limit = "256"]
 
 #[macro_use]

compiler/rustc_hir/src/stable_hash_impls.rs

@@ -1,8 +1,8 @@
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
 
 use crate::hir::{
-    BodyId, Expr, ForeignItem, ForeignItemId, ImplItem, ImplItemId, Item, ItemId, Mod, TraitItem,
-    TraitItemId, Ty, VisibilityKind,
+    BodyId, Expr, ForeignItem, ForeignItemId, ImplItem, ImplItemId, Item, ItemId, Mod, OwnerNodes,
+    TraitItem, TraitItemId, Ty, VisibilityKind,
 };
 use crate::hir_id::{HirId, ItemLocalId};
 use rustc_span::def_id::DefPathHash;
@@ -209,3 +209,12 @@ impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Item<'_> {
         });
     }
 }
+
+impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for OwnerNodes<'tcx> {
+    fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
+        // We ignore the `nodes` and `bodies` fields since these refer to information included in
+        // `hash` which is hashed in the collector and used for the crate hash.
+        let OwnerNodes { hash, node_hash: _, nodes: _, bodies: _ } = *self;
+        hash.hash_stable(hcx, hasher);
+    }
+}

compiler/rustc_middle/src/arena.rs

@@ -92,9 +92,6 @@ macro_rules! arena_types {
             [] tys: rustc_middle::ty::TyS<$tcx>,
             [] predicates: rustc_middle::ty::PredicateInner<$tcx>,
 
-            // HIR query types
-            [] indexed_hir: rustc_middle::hir::IndexedHir<$tcx>,
-
             // Note that this deliberately duplicates items in the `rustc_hir::arena`,
             // since we need to allocate this type on both the `rustc_hir` arena
             // (during lowering) and the `librustc_middle` arena (for decoding MIR)