diff options
Diffstat (limited to 'compiler/rustc_hir/src/stable_hash_impls.rs')
-rw-r--r-- | compiler/rustc_hir/src/stable_hash_impls.rs | 143 |
1 files changed, 143 insertions, 0 deletions
diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs new file mode 100644 index 000000000..8ccd59e8e --- /dev/null +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -0,0 +1,143 @@ +use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; + +use crate::hir::{ + AttributeMap, BodyId, Crate, Expr, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId, + Ty, +}; +use crate::hir_id::{HirId, ItemLocalId}; +use rustc_span::def_id::DefPathHash; + +/// Requirements for a `StableHashingContext` to be used in this crate. +/// This is a hack to allow using the `HashStable_Generic` derive macro +/// instead of implementing everything in `rustc_middle`. +pub trait HashStableContext: + rustc_ast::HashStableContext + rustc_target::HashStableContext +{ + fn hash_body_id(&mut self, _: BodyId, hasher: &mut StableHasher); + fn hash_hir_expr(&mut self, _: &Expr<'_>, hasher: &mut StableHasher); + fn hash_hir_ty(&mut self, _: &Ty<'_>, hasher: &mut StableHasher); +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for HirId { + type KeyType = (DefPathHash, ItemLocalId); + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { + let def_path_hash = self.owner.to_stable_hash_key(hcx); + (def_path_hash, self.local_id) + } +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ItemLocalId { + type KeyType = ItemLocalId; + + #[inline] + fn to_stable_hash_key(&self, _: &HirCtx) -> ItemLocalId { + *self + } +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for BodyId { + type KeyType = (DefPathHash, ItemLocalId); + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { + let BodyId { hir_id } = *self; + hir_id.to_stable_hash_key(hcx) + } +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for TraitItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ImplItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ForeignItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for BodyId { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + hcx.hash_body_id(*self, hasher) + } +} + +// The following implementations of HashStable for `ItemId`, `TraitItemId`, and +// `ImplItemId` deserve special attention. Normally we do not hash `NodeId`s within +// the HIR, since they just signify a HIR nodes own path. But `ItemId` et al +// are used when another item in the HIR is *referenced* and we certainly +// want to pick up on a reference changing its target, so we hash the NodeIds +// in "DefPath Mode". + +impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Expr<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + hcx.hash_hir_expr(self, hasher) + } +} + +impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Ty<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + hcx.hash_hir_ty(self, hasher) + } +} + +impl<'tcx, 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. + // `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 { + hash_including_bodies, + hash_without_bodies: _, + nodes: _, + bodies: _, + local_id_to_def_id: _, + } = *self; + hash_including_bodies.hash_stable(hcx, hasher); + } +} + +impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for AttributeMap<'tcx> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + // We ignore the `map` since it refers to information included in `hash` which is hashed in + // the collector and used for the crate hash. + let AttributeMap { hash, map: _ } = *self; + 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) + } +} |