Keep going

Author: Aaron1011

compiler/rustc_ast/src/ptr.rs

@@ -30,6 +30,7 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 /// An owned smart pointer.
+#[derive(HashStableEq)]
 pub struct P<T: ?Sized> {
     ptr: Box<T>,
 }

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -232,6 +232,17 @@ macro_rules! impl_stable_hash_via_hash {
     };
 }
 
+#[macro_export]
+macro_rules! impl_hash_stable_eq_via_eq {
+    ($t:ty) => {
+        impl ::rustc_data_structures::stable_hasher::HashStableEq for $t {
+            fn hash_stable_eq(&self, other: &Self) -> bool {
+                self == other
+            }
+        }
+    }
+}
+
 impl_stable_hash_via_hash!(i8);
 impl_stable_hash_via_hash!(i16);
 impl_stable_hash_via_hash!(i32);
@@ -294,6 +305,12 @@ impl<CTX> HashStable<CTX> for ::std::cmp::Ordering {
     }
 }
 
+impl<T1: HashStableEq, T2: HashStableEq> HashStableEq for (T1, T2) {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self.0.hash_stable_eq(&other.0) && self.1.hash_stable_eq(&other.1)
+    }
+}
+
 impl<T1: HashStable<CTX>, CTX> HashStable<CTX> for (T1,) {
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
         let (ref _0,) = *self;
@@ -445,6 +462,12 @@ impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for Box<T> {
     }
 }
 
+impl<T: ?Sized + HashStableEq> HashStableEq for Box<T> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        (**self).hash_stable_eq(other)
+    }
+}
+
 impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for ::std::rc::Rc<T> {
     #[inline]
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
@@ -570,6 +593,12 @@ where
     }
 }
 
+impl<'a, T: HashStableEq + ?Sized> HashStableEq for &'a T {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        (**self).hash_stable_eq(other)
+    }
+}
+
 impl<T, CTX> HashStable<CTX> for ::std::mem::Discriminant<T> {
     #[inline]
     fn hash_stable(&self, _: &mut CTX, hasher: &mut StableHasher) {

compiler/rustc_hir/src/hir.rs

@@ -1243,7 +1243,7 @@ pub enum UnsafeSource {
     UserProvided,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug, HashStableEq)]
 pub struct BodyId {
     pub hir_id: HirId,
 }
@@ -1476,7 +1476,7 @@ pub struct AnonConst {
 }
 
 /// An expression.
-#[derive(Debug)]
+#[derive(Debug, HashStableEq)]
 pub struct Expr<'hir> {
     pub hir_id: HirId,
     pub kind: ExprKind<'hir>,
@@ -2029,7 +2029,7 @@ pub struct FnSig<'hir> {
 // The bodies for items are stored "out of line", in a separate
 // hashmap in the `Crate`. Here we just record the hir-id of the item
 // so it can fetched later.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStableEq)]
 pub struct TraitItemId {
     pub def_id: LocalDefId,
 }
@@ -2046,7 +2046,7 @@ impl TraitItemId {
 /// possibly including a default implementation. A trait item is
 /// either required (meaning it doesn't have an implementation, just a
 /// signature) or provided (meaning it has a default implementation).
-#[derive(Debug)]
+#[derive(Debug, HashStableEq)]
 pub struct TraitItem<'hir> {
     pub ident: Ident,
     pub def_id: LocalDefId,
@@ -2092,7 +2092,7 @@ pub enum TraitItemKind<'hir> {
 // The bodies for items are stored "out of line", in a separate
 // hashmap in the `Crate`. Here we just record the hir-id of the item
 // so it can fetched later.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStableEq)]
 pub struct ImplItemId {
     pub def_id: LocalDefId,
 }
@@ -2106,7 +2106,7 @@ impl ImplItemId {
 }
 
 /// Represents anything within an `impl` block.
-#[derive(Debug)]
+#[derive(Debug, HashStableEq)]
 pub struct ImplItem<'hir> {
     pub ident: Ident,
     pub def_id: LocalDefId,
@@ -2209,7 +2209,7 @@ impl TypeBinding<'_> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, HashStableEq)]
 pub struct Ty<'hir> {
     pub hir_id: HirId,
     pub kind: TyKind<'hir>,
@@ -2607,7 +2607,7 @@ pub struct PolyTraitRef<'hir> {
 
 pub type Visibility<'hir> = Spanned<VisibilityKind<'hir>>;
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, HashStableEq)]
 pub enum VisibilityKind<'hir> {
     Public,
     Crate(CrateSugar),
@@ -2683,7 +2683,7 @@ impl<'hir> VariantData<'hir> {
 // The bodies for items are stored "out of line", in a separate
 // hashmap in the `Crate`. Here we just record the hir-id of the item
 // so it can fetched later.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, Hash, HashStableEq)]
 pub struct ItemId {
     pub def_id: LocalDefId,
 }
@@ -2699,7 +2699,7 @@ impl ItemId {
 /// An item
 ///
 /// The name might be a dummy name in case of anonymous items
-#[derive(Debug)]
+#[derive(Debug, HashStableEq)]
 pub struct Item<'hir> {
     pub ident: Ident,
     pub def_id: LocalDefId,
@@ -2926,7 +2926,7 @@ pub enum AssocItemKind {
 // The bodies for items are stored "out of line", in a separate
 // hashmap in the `Crate`. Here we just record the hir-id of the item
 // so it can fetched later.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStableEq)]
 pub struct ForeignItemId {
     pub def_id: LocalDefId,
 }
@@ -2952,7 +2952,7 @@ pub struct ForeignItemRef {
     pub span: Span,
 }
 
-#[derive(Debug)]
+#[derive(Debug, HashStableEq)]
 pub struct ForeignItem<'hir> {
     pub ident: Ident,
     pub kind: ForeignItemKind<'hir>,

compiler/rustc_hir/src/lang_items.rs

@@ -44,7 +44,7 @@ macro_rules! language_item_table {
 
         enum_from_u32! {
             /// A representation of all the valid language items in Rust.
-            #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)]
+            #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, HashStableEq)]
             pub enum LangItem {
                 $(
                     #[doc = concat!("The `", stringify!($name), "` lang item.")]
@@ -84,6 +84,7 @@ macro_rules! language_item_table {
         /// All of the language items, defined or not.
         /// Defined lang items can come from the current crate or its dependencies.
         #[derive(HashStable_Generic, Debug)]
+        #[stable_hasher(no_hash_stable_eq)]
         pub struct LanguageItems {
             /// Mappings from lang items to their possibly found [`DefId`]s.
             /// The index corresponds to the order in [`LangItem`].

compiler/rustc_hir/src/stable_hash_impls.rs

@@ -1,4 +1,4 @@
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey, HashStableEq};
 
 use crate::hir::{
     AttributeMap, BodyId, Crate, Expr, ForeignItem, ForeignItemId, ImplItem, ImplItemId, Item,
@@ -33,6 +33,12 @@ impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for HirId {
     }
 }
 
+impl HashStableEq for HirId {
+    fn hash_stable_eq(&self, other: &HirId) -> bool {
+        self == other
+    }
+}
+
 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ItemLocalId {
     type KeyType = ItemLocalId;
 

compiler/rustc_span/src/def_id.rs

@@ -192,6 +192,7 @@ rustc_index::newtype_index! {
     /// A DefIndex is an index into the hir-map for a crate, identifying a
     /// particular definition. It should really be considered an interned
     /// shorthand for a particular DefPath.
+    #[derive(HashStableEq)]
     pub struct DefIndex {
         ENCODABLE = custom // (only encodable in metadata)
 
@@ -333,7 +334,7 @@ rustc_data_structures::define_id_collections!(DefIdMap, DefIdSet, DefId);
 /// few cases where we know that only `DefId`s from the local crate are expected;
 /// a `DefId` from a different crate would signify a bug somewhere. This
 /// is when `LocalDefId` comes in handy.
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, HashStableEq)]
 pub struct LocalDefId {
     pub local_def_index: DefIndex,
 }