compiler/rustc_hir/src/stable_hash_impls.rs

   1 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
   2
   3 use crate::hir::{
   4     AttributeMap, BodyId, Crate, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId,
   5 };
   6 use crate::hir_id::{HirId, ItemLocalId};
   7 use rustc_span::def_id::DefPathHash;
   8
   9 /// Requirements for a `StableHashingContext` to be used in this crate.
  10 /// This is a hack to allow using the `HashStable_Generic` derive macro
  11 /// instead of implementing everything in `rustc_middle`.
  12 pub trait HashStableContext:
  13     rustc_ast::HashStableContext + rustc_target::HashStableContext
  14 {
  15     fn hash_body_id(&mut self, _: BodyId, hasher: &mut StableHasher);
  16 }
  17
  18 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for HirId {
  19     type KeyType = (DefPathHash, ItemLocalId);
  20
  21     #[inline]
  22     fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) {
  23         let def_path_hash = self.owner.def_id.to_stable_hash_key(hcx);
  24         (def_path_hash, self.local_id)
  25     }
  26 }
  27
  28 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ItemLocalId {
  29     type KeyType = ItemLocalId;
  30
  31     #[inline]
  32     fn to_stable_hash_key(&self, _: &HirCtx) -> ItemLocalId {
  33         *self
  34     }
  35 }
  36
  37 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for BodyId {
  38     type KeyType = (DefPathHash, ItemLocalId);
  39
  40     #[inline]
  41     fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) {
  42         let BodyId { hir_id } = *self;
  43         hir_id.to_stable_hash_key(hcx)
  44     }
  45 }
  46
  47 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ItemId {
  48     type KeyType = DefPathHash;
  49
  50     #[inline]
  51     fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash {
  52         self.owner_id.def_id.to_stable_hash_key(hcx)
  53     }
  54 }
  55
  56 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for TraitItemId {
  57     type KeyType = DefPathHash;
  58
  59     #[inline]
  60     fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash {
  61         self.owner_id.def_id.to_stable_hash_key(hcx)
  62     }
  63 }
  64
  65 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ImplItemId {
  66     type KeyType = DefPathHash;
  67
  68     #[inline]
  69     fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash {
  70         self.owner_id.def_id.to_stable_hash_key(hcx)
  71     }
  72 }
  73
  74 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ForeignItemId {
  75     type KeyType = DefPathHash;
  76
  77     #[inline]
  78     fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash {
  79         self.owner_id.def_id.to_stable_hash_key(hcx)
  80     }
  81 }
  82
  83 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for BodyId {
  84     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
  85         hcx.hash_body_id(*self, hasher)
  86     }
  87 }
  88
  89 // The following implementations of HashStable for `ItemId`, `TraitItemId`, and
  90 // `ImplItemId` deserve special attention. Normally we do not hash `NodeId`s within
  91 // the HIR, since they just signify a HIR nodes own path. But `ItemId` et al
  92 // are used when another item in the HIR is *referenced* and we certainly
  93 // want to pick up on a reference changing its target, so we hash the NodeIds
  94 // in "DefPath Mode".
  95
  96 impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for OwnerNodes<'tcx> {
  97     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
  98         // We ignore the `nodes` and `bodies` fields since these refer to information included in
  99         // `hash` which is hashed in the collector and used for the crate hash.
 100         // `local_id_to_def_id` is also ignored because is dependent on the body, then just hashing
 101         // the body satisfies the condition of two nodes being different have different
 102         // `hash_stable` results.
 103         let OwnerNodes {
 104             hash_including_bodies,
 105             hash_without_bodies: _,
 106             nodes: _,
 107             bodies: _,
 108             local_id_to_def_id: _,
 109         } = *self;
 110         hash_including_bodies.hash_stable(hcx, hasher);
 111     }
 112 }
 113
 114 impl<'tcx, HirCtx: crate::HashStableContext> HashStable<HirCtx> for AttributeMap<'tcx> {
 115     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
 116         // We ignore the `map` since it refers to information included in `hash` which is hashed in
 117         // the collector and used for the crate hash.
 118         let AttributeMap { hash, map: _ } = *self;
 119         hash.hash_stable(hcx, hasher);
 120     }
 121 }
 122
 123 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Crate<'_> {
 124     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
 125         let Crate { owners: _, hir_hash } = self;
 126         hir_hash.hash_stable(hcx, hasher)
 127     }
 128 }