Only return LocalDefId in hir_crate.

cjgillot · cjgillot · commit 9a227cab1097 · 2022-04-30T15:35:33.000+02:00
diff --git a/compiler/rustc_ast_lowering/src/query.rs b/compiler/rustc_ast_lowering/src/query.rs
@@ -1,23 +1,87 @@
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::svh::Svh;
-use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, LOCAL_CRATE};
+use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, CRATE_DEF_ID, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{ForeignItem, ImplItem, Item, ItemKind, Mod, TraitItem};
+use rustc_hir::{Crate, ForeignItem, ImplItem, Item, ItemKind, Mod, TraitItem};
 use rustc_hir::{ForeignItemId, HirId, ImplItemId, ItemId, ModuleItems, TraitItemId};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::TyCtxt;
-use rustc_span::Span;
+use rustc_span::{Span, DUMMY_SP};
 
 pub fn provide(providers: &mut Providers) {
-    *providers = Providers { crate_hash, hir_module_items, hir_crate_items, ..*providers };
+    *providers =
+        Providers { hir_crate, crate_hash, hir_module_items, hir_crate_items, ..*providers };
+}
+
+fn hir_crate<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> Crate<'tcx> {
+    let mut collector = CrateCollector { tcx, owners: vec![CRATE_DEF_ID] };
+    tcx.hir().walk_toplevel_module(&mut collector);
+    let owners = tcx.arena.alloc_from_iter(collector.owners);
+
+    // Discard hygiene data, which isn't required after lowering to HIR.
+    if !tcx.sess.opts.debugging_opts.keep_hygiene_data {
+        rustc_span::hygiene::clear_syntax_context_map();
+    }
+
+    return Crate { owners };
+
+    struct CrateCollector<'tcx> {
+        tcx: TyCtxt<'tcx>,
+        owners: Vec<LocalDefId>,
+    }
+
+    impl<'hir> Visitor<'hir> for CrateCollector<'hir> {
+        type NestedFilter = nested_filter::All;
+
+        fn nested_visit_map(&mut self) -> Self::Map {
+            self.tcx.hir()
+        }
+
+        fn visit_item(&mut self, item: &'hir Item<'hir>) {
+            self.owners.push(item.def_id);
+            intravisit::walk_item(self, item)
+        }
+
+        fn visit_trait_item(&mut self, item: &'hir TraitItem<'hir>) {
+            self.owners.push(item.def_id);
+            intravisit::walk_trait_item(self, item)
+        }
+
+        fn visit_impl_item(&mut self, item: &'hir ImplItem<'hir>) {
+            self.owners.push(item.def_id);
+            intravisit::walk_impl_item(self, item)
+        }
+
+        fn visit_foreign_item(&mut self, item: &'hir ForeignItem<'hir>) {
+            self.owners.push(item.def_id);
+            intravisit::walk_foreign_item(self, item)
+        }
+    }
 }
 
 fn crate_hash(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Svh {
     debug_assert_eq!(crate_num, LOCAL_CRATE);
     let krate = tcx.hir_crate(());
-    let hir_body_hash = krate.hir_hash;
+    let definitions = tcx.definitions_untracked();
+
+    let mut hir_body_nodes: Vec<_> = krate
+        .owners
+        .iter()
+        .map(|&def_id| {
+            let def_path_hash = tcx.hir().def_path_hash(def_id);
+            let info = tcx.lower_to_hir(def_id).unwrap();
+            let span = if tcx.sess.opts.debugging_opts.incremental_relative_spans {
+                definitions.def_span(def_id)
+            } else {
+                DUMMY_SP
+            };
+            debug_assert_eq!(span.parent(), None);
+            (def_path_hash, info, span)
+        })
+        .collect();
+    hir_body_nodes.sort_unstable_by_key(|bn| bn.0);
 
     let upstream_crates = upstream_crates(tcx);
 
@@ -39,25 +103,9 @@ fn crate_hash(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Svh {
 
     let crate_hash: Fingerprint = tcx.with_stable_hashing_context(|mut hcx| {
         let mut stable_hasher = StableHasher::new();
-        hir_body_hash.hash_stable(&mut hcx, &mut stable_hasher);
+        hir_body_nodes.hash_stable(&mut hcx, &mut stable_hasher);
         upstream_crates.hash_stable(&mut hcx, &mut stable_hasher);
         source_file_names.hash_stable(&mut hcx, &mut stable_hasher);
-        if tcx.sess.opts.debugging_opts.incremental_relative_spans {
-            let definitions = tcx.definitions_untracked();
-            let mut owner_spans: Vec<_> = krate
-                .owners
-                .iter_enumerated()
-                .filter_map(|(def_id, info)| {
-                    let _ = info.as_owner()?;
-                    let def_path_hash = definitions.def_path_hash(def_id);
-                    let span = definitions.def_span(def_id);
-                    debug_assert_eq!(span.parent(), None);
-                    Some((def_path_hash, span))
-                })
-                .collect();
-            owner_spans.sort_unstable_by_key(|bn| bn.0);
-            owner_spans.hash_stable(&mut hcx, &mut stable_hasher);
-        }
         tcx.sess.opts.dep_tracking_hash(true).hash_stable(&mut hcx, &mut stable_hasher);
         tcx.sess.local_stable_crate_id().hash_stable(&mut hcx, &mut stable_hasher);
         // Hash visibility information since it does not appear in HIR.
diff --git a/compiler/rustc_driver/src/pretty.rs b/compiler/rustc_driver/src/pretty.rs
@@ -461,7 +461,12 @@ pub fn print_after_hir_lowering<'tcx>(
         HirTree => {
             call_with_pp_support_hir(&PpHirMode::Normal, tcx, move |_annotation, hir_map| {
                 debug!("pretty printing HIR tree");
-                format!("{:#?}", hir_map.krate())
+                hir_map
+                    .krate()
+                    .owners
+                    .iter()
+                    .map(|&owner| format!("{:#?} => {:#?}\n", owner, tcx.lower_to_hir(owner)))
+                    .collect()
             })
         }
 
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -831,10 +831,10 @@ impl ModuleItems {
 /// For more details, see the [rustc dev guide].
 ///
 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
-#[derive(Debug)]
+#[derive(Debug, HashStable_Generic)]
 pub struct Crate<'hir> {
-    pub owners: IndexVec<LocalDefId, MaybeOwner<&'hir OwnerInfo<'hir>>>,
-    pub hir_hash: Fingerprint,
+    /// List of all the definitions in visitor order.
+    pub owners: &'hir [LocalDefId],
 }
 
 /// A block of statements `{ .. }`, which may have a label (in this case the
diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs
@@ -1,8 +1,7 @@
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
 
 use crate::hir::{
-    AttributeMap, BodyId, Crate, Expr, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId,
-    Ty,
+    AttributeMap, BodyId, Expr, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId, Ty,
 };
 use crate::hir_id::{HirId, ItemLocalId};
 use rustc_span::def_id::DefPathHash;
@@ -134,10 +133,3 @@ impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for AttributeMap
         hash.hash_stable(hcx, hasher);
     }
 }
-
-impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Crate<'_> {
-    fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
-        let Crate { owners: _, hir_hash } = self;
-        hir_hash.hash_stable(hcx, hasher)
-    }
-}
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
@@ -8,15 +8,12 @@ use rustc_borrowck as mir_borrowck;
 use rustc_codegen_ssa::back::link::emit_metadata;
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::parallel;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{Lrc, OnceCell, WorkerLocal};
 use rustc_data_structures::temp_dir::MaybeTempDir;
 use rustc_errors::{Applicability, ErrorGuaranteed, MultiSpan, PResult};
 use rustc_expand::base::{ExtCtxt, LintStoreExpand, ResolverExpand};
-use rustc_hir::def_id::{LocalDefId, StableCrateId, LOCAL_CRATE};
+use rustc_hir::def_id::{StableCrateId, LOCAL_CRATE};
 use rustc_hir::definitions::Definitions;
-use rustc_hir::Crate;
-use rustc_index::vec::{Idx, IndexVec};
 use rustc_lint::{EarlyCheckNode, LintStore};
 use rustc_metadata::creader::CStore;
 use rustc_metadata::{encode_metadata, EncodedMetadata};
@@ -492,39 +489,6 @@ pub fn configure_and_expand(
     Ok(krate)
 }
 
-fn hir_crate<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> Crate<'tcx> {
-    let mut owners: IndexVec<LocalDefId, _> = IndexVec::new();
-    while owners.next_index().index() < tcx.definitions_untracked().def_index_count() {
-        let next = owners.next_index();
-        owners.push(tcx.lower_to_hir(next));
-    }
-
-    // Discard hygiene data, which isn't required after lowering to HIR.
-    if !tcx.sess.opts.debugging_opts.keep_hygiene_data {
-        rustc_span::hygiene::clear_syntax_context_map();
-    }
-
-    let mut hir_body_nodes: Vec<_> = owners
-        .iter_enumerated()
-        .filter_map(|(def_id, info)| {
-            let info = info.as_owner()?;
-            let def_path_hash = tcx.hir().def_path_hash(def_id);
-            Some((def_path_hash, info))
-        })
-        .collect();
-    hir_body_nodes.sort_unstable_by_key(|bn| bn.0);
-
-    let hir_hash = tcx.with_stable_hashing_context(|mut hcx| {
-        let mut stable_hasher = StableHasher::new();
-        hir_body_nodes.hash_stable(&mut hcx, &mut stable_hasher);
-        stable_hasher.finish()
-    });
-
-    let hir_crate = Crate { owners, hir_hash };
-
-    hir_crate
-}
-
 // Returns all the paths that correspond to generated files.
 fn generated_output_paths(
     sess: &Session,
@@ -789,7 +753,6 @@ pub fn prepare_outputs(
 pub static DEFAULT_QUERY_PROVIDERS: SyncLazy<Providers> = SyncLazy::new(|| {
     let providers = &mut Providers::default();
     providers.analysis = analysis;
-    providers.hir_crate = hir_crate;
     providers.lower_to_hir =
         |tcx, def_id| rustc_ast_lowering::lower_to_hir(tcx, def_id, rustc_parse::nt_to_tokenstream);
     rustc_ast_lowering::provide(providers);
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -499,34 +499,28 @@ impl<'hir> Map<'hir> {
     /// crate. If you would prefer to iterate over the bodies
     /// themselves, you can do `self.hir().krate().body_ids.iter()`.
     pub fn body_owners(self) -> impl Iterator<Item = LocalDefId> + 'hir {
-        self.krate()
-            .owners
-            .iter_enumerated()
-            .flat_map(move |(owner, owner_info)| {
-                let bodies = &owner_info.as_owner()?.nodes.bodies;
-                Some(bodies.iter().map(move |&(local_id, _)| {
-                    let hir_id = HirId { owner, local_id };
-                    let body_id = BodyId { hir_id };
-                    self.body_owner_def_id(body_id)
-                }))
+        self.krate().owners.iter().flat_map(move |&owner| {
+            let bodies = &self.tcx.hir_owner_nodes(owner).unwrap().bodies;
+            bodies.iter().filter_map(move |(local_id, _)| {
+                let hir_id = HirId { owner, local_id: *local_id };
+                let body_id = BodyId { hir_id };
+                Some(self.body_owner_def_id(body_id))
             })
-            .flatten()
+        })
     }
 
     pub fn par_body_owners<F: Fn(LocalDefId) + Sync + Send>(self, f: F) {
         use rustc_data_structures::sync::{par_iter, ParallelIterator};
         #[cfg(parallel_compiler)]
         use rustc_rayon::iter::IndexedParallelIterator;
 
-        par_iter(&self.krate().owners.raw).enumerate().for_each(|(owner, owner_info)| {
-            let owner = LocalDefId::new(owner);
-            if let MaybeOwner::Owner(owner_info) = owner_info {
-                par_iter(owner_info.nodes.bodies.range(..)).for_each(|(local_id, _)| {
-                    let hir_id = HirId { owner, local_id: *local_id };
-                    let body_id = BodyId { hir_id };
-                    f(self.body_owner_def_id(body_id))
-                })
-            }
+        par_iter(&*self.krate().owners).for_each(|&owner| {
+            let owner_info = self.tcx.lower_to_hir(owner).unwrap();
+            par_iter(owner_info.nodes.bodies.range(..)).for_each(|(local_id, _)| {
+                let hir_id = HirId { owner, local_id: *local_id };
+                let body_id = BodyId { hir_id };
+                f(self.body_owner_def_id(body_id))
+            })
         });
     }
 
@@ -583,13 +577,12 @@ impl<'hir> Map<'hir> {
     /// Walks the attributes in a crate.
     pub fn walk_attributes(self, visitor: &mut impl Visitor<'hir>) {
         let krate = self.krate();
-        for (owner, info) in krate.owners.iter_enumerated() {
-            if let MaybeOwner::Owner(info) = info {
-                for (local_id, attrs) in info.attrs.map.iter() {
-                    let id = HirId { owner, local_id: *local_id };
-                    for a in *attrs {
-                        visitor.visit_attribute(id, a)
-                    }
+        for &owner in krate.owners.iter() {
+            let info = self.tcx.lower_to_hir(owner).unwrap();
+            for (local_id, attrs) in info.attrs.map.iter() {
+                let id = HirId { owner, local_id: *local_id };
+                for a in *attrs {
+                    visitor.visit_attribute(id, a)
                 }
             }
         }
@@ -608,8 +601,9 @@ impl<'hir> Map<'hir> {
         V: itemlikevisit::ItemLikeVisitor<'hir>,
     {
         let krate = self.krate();
-        for owner in krate.owners.iter().filter_map(|i| i.as_owner()) {
-            match owner.node() {
+        for &owner in krate.owners.iter() {
+            let info = self.tcx.hir_owner(owner).unwrap();
+            match info.node {
                 OwnerNode::Item(item) => visitor.visit_item(item),
                 OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
                 OwnerNode::ImplItem(item) => visitor.visit_impl_item(item),
@@ -625,12 +619,12 @@ impl<'hir> Map<'hir> {
         V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send,
     {
         let krate = self.krate();
-        par_for_each_in(&krate.owners.raw, |owner| match owner.map(OwnerInfo::node) {
-            MaybeOwner::Owner(OwnerNode::Item(item)) => visitor.visit_item(item),
-            MaybeOwner::Owner(OwnerNode::ForeignItem(item)) => visitor.visit_foreign_item(item),
-            MaybeOwner::Owner(OwnerNode::ImplItem(item)) => visitor.visit_impl_item(item),
-            MaybeOwner::Owner(OwnerNode::TraitItem(item)) => visitor.visit_trait_item(item),
-            MaybeOwner::Owner(OwnerNode::Crate(_)) | MaybeOwner::NonOwner(_) => {}
+        par_for_each_in(&*krate.owners, |&owner| match self.tcx.hir_owner(owner).unwrap().node {
+            OwnerNode::Item(item) => visitor.visit_item(item),
+            OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
+            OwnerNode::ImplItem(item) => visitor.visit_impl_item(item),
+            OwnerNode::TraitItem(item) => visitor.visit_trait_item(item),
+            OwnerNode::Crate(_) => {}
         })
     }
 
