Precompute hash for OwnerInfo too.

Author: cjgillot

compiler/rustc_ast_lowering/src/lib.rs

@@ -45,6 +45,7 @@ use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{self as ast, *};
 use rustc_attr_parsing::{AttributeParser, Late, OmitDoc};
 use rustc_data_structures::sorted_map::SortedMap;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::tagged_ptr::TaggedRef;
 use rustc_data_structures::unord::ExtendUnord;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle};
@@ -700,16 +701,32 @@ impl<'hir> LoweringContext<'hir> {
         let bodies = SortedMap::from_presorted_elements(bodies);
 
         // Don't hash unless necessary, because it's expensive.
-        let rustc_middle::hir::Hashes { opt_hash_including_bodies, attrs_hash, delayed_lints_hash } =
+        let rustc_middle::hir::Hashes { bodies_hash, attrs_hash, delayed_lints_hash } =
             self.tcx.hash_owner_nodes(node, &bodies, &attrs, &delayed_lints, define_opaque);
         let num_nodes = self.item_local_id_counter.as_usize();
         let (nodes, parenting) = index::index_hir(self.tcx, node, &bodies, num_nodes);
-        let nodes = hir::OwnerNodes { opt_hash_including_bodies, nodes, bodies };
+        let nodes = hir::OwnerNodes { opt_hash: bodies_hash, nodes, bodies };
         let attrs = hir::AttributeMap { map: attrs, opt_hash: attrs_hash, define_opaque };
         let delayed_lints =
             hir::lints::DelayedLints { lints: delayed_lints, opt_hash: delayed_lints_hash };
 
+        let opt_hash = if self.tcx.needs_crate_hash() {
+            Some(self.tcx.with_stable_hashing_context(|mut hcx| {
+                let mut stable_hasher = StableHasher::new();
+                bodies_hash.unwrap().hash_stable(&mut hcx, &mut stable_hasher);
+                attrs_hash.unwrap().hash_stable(&mut hcx, &mut stable_hasher);
+                delayed_lints_hash.unwrap().hash_stable(&mut hcx, &mut stable_hasher);
+                parenting.hash_stable(&mut hcx, &mut stable_hasher);
+                trait_map.hash_stable(&mut hcx, &mut stable_hasher);
+                children.hash_stable(&mut hcx, &mut stable_hasher);
+                stable_hasher.finish()
+            }))
+        } else {
+            None
+        };
+
         self.arena.alloc(hir::OwnerInfo {
+            opt_hash,
             nodes,
             parenting,
             attrs,

compiler/rustc_hir/src/hir.rs

@@ -1507,7 +1507,7 @@ impl<'tcx> AttributeMap<'tcx> {
 pub struct OwnerNodes<'tcx> {
     /// Pre-computed hash of the full HIR. Used in the crate hash. Only present
     /// when incr. comp. is enabled.
-    pub opt_hash_including_bodies: Option<Fingerprint>,
+    pub opt_hash: Option<Fingerprint>,
     /// Full HIR for the current owner.
     // The zeroth node's parent should never be accessed: the owner's parent is computed by the
     // hir_owner_parent query. It is set to `ItemLocalId::INVALID` to force an ICE if accidentally
@@ -1540,13 +1540,13 @@ impl fmt::Debug for OwnerNodes<'_> {
                 }),
             )
             .field("bodies", &self.bodies)
-            .field("opt_hash_including_bodies", &self.opt_hash_including_bodies)
+            .field("opt_hash", &self.opt_hash)
             .finish()
     }
 }
 
 /// Full information resulting from lowering an AST node.
-#[derive(Debug, HashStable_Generic)]
+#[derive(Debug)]
 pub struct OwnerInfo<'hir> {
     /// Contents of the HIR.
     pub nodes: OwnerNodes<'hir>,
@@ -1562,6 +1562,8 @@ pub struct OwnerInfo<'hir> {
     pub delayed_lints: DelayedLints,
     /// Owners generated as side-effect by lowering.
     pub children: UnordMap<LocalDefId, MaybeOwner<'hir>>,
+    // Only present when the crate hash is needed.
+    pub opt_hash: Option<Fingerprint>,
 }
 
 impl<'tcx> OwnerInfo<'tcx> {

compiler/rustc_hir/src/stable_hash_impls.rs

@@ -3,7 +3,7 @@ use rustc_span::def_id::DefPathHash;
 
 use crate::HashIgnoredAttrId;
 use crate::hir::{
-    AttributeMap, BodyId, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId,
+    AttributeMap, BodyId, ForeignItemId, ImplItemId, ItemId, OwnerInfo, OwnerNodes, TraitItemId,
 };
 use crate::hir_id::ItemLocalId;
 use crate::lints::DelayedLints;
@@ -69,25 +69,25 @@ impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ForeignItemId
 // in "DefPath Mode".
 
 impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for OwnerNodes<'tcx> {
+    #[inline]
     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.
-        // `local_id_to_def_id` is also ignored because is dependent on the body, then just hashing
-        // the body satisfies the condition of two nodes being different have different
-        // `hash_stable` results.
-        let OwnerNodes { opt_hash_including_bodies, nodes: _, bodies: _ } = *self;
-        opt_hash_including_bodies.unwrap().hash_stable(hcx, hasher);
+        // We ignore the other fields since these refer to information included in
+        // `opt_hash` which is hashed in the collector and used for the crate hash.
+        let OwnerNodes { opt_hash, .. } = *self;
+        opt_hash.unwrap().hash_stable(hcx, hasher);
     }
 }
 
 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for DelayedLints {
+    #[inline]
     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
         let DelayedLints { opt_hash, .. } = *self;
         opt_hash.unwrap().hash_stable(hcx, hasher);
     }
 }
 
 impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for AttributeMap<'tcx> {
+    #[inline]
     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
         // We ignore the `map` since it refers to information included in `opt_hash` which is
         // hashed in the collector and used for the crate hash.
@@ -96,6 +96,16 @@ impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for AttributeMap
     }
 }
 
+impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for OwnerInfo<'tcx> {
+    #[inline]
+    fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
+        // We ignore the rest since it refers to information included in `opt_hash` which is
+        // hashed in the collector and used for the crate hash.
+        let OwnerInfo { opt_hash, .. } = *self;
+        opt_hash.unwrap().hash_stable(hcx, hasher);
+    }
+}
+
 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for HashIgnoredAttrId {
     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
         hcx.hash_attr_id(self, hasher)

compiler/rustc_middle/src/hir/mod.rs

@@ -169,11 +169,7 @@ impl<'tcx> TyCtxt<'tcx> {
         define_opaque: Option<&[(Span, LocalDefId)]>,
     ) -> Hashes {
         if !self.needs_crate_hash() {
-            return Hashes {
-                opt_hash_including_bodies: None,
-                attrs_hash: None,
-                delayed_lints_hash: None,
-            };
+            return Hashes { bodies_hash: None, attrs_hash: None, delayed_lints_hash: None };
         }
 
         self.with_stable_hashing_context(|mut hcx| {
@@ -196,19 +192,15 @@ impl<'tcx> TyCtxt<'tcx> {
             delayed_lints.hash_stable(&mut hcx, &mut stable_hasher);
             let h3 = stable_hasher.finish();
 
-            Hashes {
-                opt_hash_including_bodies: Some(h1),
-                attrs_hash: Some(h2),
-                delayed_lints_hash: Some(h3),
-            }
+            Hashes { bodies_hash: Some(h1), attrs_hash: Some(h2), delayed_lints_hash: Some(h3) }
         })
     }
 }
 
 /// Hashes computed by [`TyCtxt::hash_owner_nodes`] if necessary.
 #[derive(Clone, Copy, Debug)]
 pub struct Hashes {
-    pub opt_hash_including_bodies: Option<Fingerprint>,
+    pub bodies_hash: Option<Fingerprint>,
     pub attrs_hash: Option<Fingerprint>,
     pub delayed_lints_hash: Option<Fingerprint>,
 }

compiler/rustc_middle/src/ty/context.rs

@@ -1493,11 +1493,11 @@ impl<'tcx> TyCtxtFeed<'tcx, LocalDefId> {
         let bodies = Default::default();
         let attrs = hir::AttributeMap::EMPTY;
 
-        let rustc_middle::hir::Hashes { opt_hash_including_bodies, .. } =
+        let rustc_middle::hir::Hashes { bodies_hash, .. } =
             self.tcx.hash_owner_nodes(node, &bodies, &attrs.map, &[], attrs.define_opaque);
         let node = node.into();
         self.opt_hir_owner_nodes(Some(self.tcx.arena.alloc(hir::OwnerNodes {
-            opt_hash_including_bodies,
+            opt_hash: bodies_hash,
             nodes: IndexVec::from_elem_n(
                 hir::ParentedNode { parent: hir::ItemLocalId::INVALID, node },
                 1,

compiler/rustc_mir_transform/src/coverage/hir_info.rs

@@ -69,7 +69,7 @@ pub(crate) fn extract_hir_info<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> E
 fn hash_mir_source<'tcx>(tcx: TyCtxt<'tcx>, hir_body: &'tcx hir::Body<'tcx>) -> u64 {
     let owner = hir_body.id().hir_id.owner;
     tcx.hir_owner_nodes(owner)
-        .opt_hash_including_bodies
+        .opt_hash
         .expect("hash should be present when coverage instrumentation is enabled")
         .to_smaller_hash()
         .as_u64()