Get rustc_middle compiling

Aaron1011 · Aaron1011 · commit 95c40b8e373d · 2022-02-17T16:21:03.000-05:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -2027,7 +2027,6 @@ bitflags::bitflags! {
 }
 
 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Hash, HashStable_Generic)]
-#[stable_hasher(no_hash_stable_eq)]
 pub enum InlineAsmTemplatePiece {
     String(String),
     Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },
diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs
@@ -93,7 +93,6 @@ pub enum OptimizeAttr {
 /// - `#[unstable]`
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[derive(HashStable_Generic)]
-#[stable_hasher(no_hash_stable_eq)]
 pub struct Stability {
     pub level: StabilityLevel,
     pub feature: Symbol,
@@ -102,7 +101,6 @@ pub struct Stability {
 /// Represents the `#[rustc_const_unstable]` and `#[rustc_const_stable]` attributes.
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[derive(HashStable_Generic)]
-#[stable_hasher(no_hash_stable_eq)]
 pub struct ConstStability {
     pub level: StabilityLevel,
     pub feature: Symbol,
@@ -113,7 +111,6 @@ pub struct ConstStability {
 /// The available stability levels.
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
 #[derive(HashStable_Generic)]
-#[stable_hasher(no_hash_stable_eq)]
 pub enum StabilityLevel {
     // Reason for the current stability level and the relevant rust-lang issue
     Unstable { reason: Option<Symbol>, issue: Option<NonZeroU32>, is_soft: bool },
diff --git a/compiler/rustc_data_structures/src/sorted_map.rs b/compiler/rustc_data_structures/src/sorted_map.rs
@@ -1,4 +1,4 @@
-use crate::stable_hasher::{HashStable, StableHasher};
+use crate::stable_hasher::{HashStable, HashStableEq, StableHasher};
 use std::borrow::Borrow;
 use std::cmp::Ordering;
 use std::iter::FromIterator;
@@ -298,5 +298,11 @@ impl<K: HashStable<CTX>, V: HashStable<CTX>, CTX> HashStable<CTX> for SortedMap<
     }
 }
 
+impl<K: HashStableEq, V: HashStableEq> HashStableEq for SortedMap<K, V> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self.data.hash_stable_eq(&other.data)
+    }
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/compiler/rustc_data_structures/src/stable_hasher.rs b/compiler/rustc_data_structures/src/stable_hasher.rs
@@ -285,6 +285,18 @@ impl HashStableEq for ::std::num::NonZeroUsize {
     }
 }
 
+impl HashStableEq for ::std::num::NonZeroU32 {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self.get().hash_stable_eq(&other.get())
+    }
+}
+
+impl HashStableEq for ::std::num::NonZeroU64 {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self.get().hash_stable_eq(&other.get())
+    }
+}
+
 impl<CTX> HashStable<CTX> for f32 {
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
         let val: u32 = unsafe { ::std::mem::transmute(*self) };
@@ -424,6 +436,25 @@ impl<T: HashStableEq> HashStableEq for Vec<T> {
     }
 }
 
+impl<K: HashStableEq + Eq + Hash, V: HashStableEq, R: BuildHasher> HashStableEq for indexmap::IndexMap<K, V, R> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+        // Equal maps will have equal iteration orders
+        // FIXME -is that actually right?
+        self.iter().zip(other.iter()).all(|(first, second)| {
+            first.hash_stable_eq(&second)
+        })
+    }
+}
+
+impl<T> HashStableEq for std::marker::PhantomData<T> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        true
+    }
+}
+
 impl<K, V, R, CTX> HashStable<CTX> for indexmap::IndexMap<K, V, R>
 where
     K: HashStable<CTX> + Eq + Hash,
@@ -463,6 +494,12 @@ where
     }
 }
 
+impl<A: smallvec::Array> HashStableEq for SmallVec<A> where <A as smallvec::Array>::Item: HashStableEq {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        (&self[..]).hash_stable_eq(other)
+    }
+}
+
 impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for Box<T> {
     #[inline]
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
@@ -693,6 +730,49 @@ where
     }
 }
 
+impl<K, V, R> HashStableEq for ::std::collections::HashMap<K, V, R>
+where
+    K: HashStableEq + Eq + Hash,
+    V: HashStableEq,
+    R: BuildHasher,
+{
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+        self.iter().all(|(key, value)| {
+            match other.get_key_value(key) {
+                Some((other_key, other_value)) => {
+                    // Compare the key, since the `PartailEq` impl
+                    // used by the map may ignore information
+                    key.hash_stable_eq(other_key) && value.hash_stable_eq(other_value)
+                }
+                _ => false,
+            }
+        })
+    }
+}
+
+impl<K, R> HashStableEq for ::std::collections::HashSet<K, R>
+where
+    K: HashStableEq + Eq + Hash,
+    R: BuildHasher,
+{
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+        self.iter().all(|key| {
+            match other.get(key) {
+                // Compare the key, since the `PartailEq` impl
+                // used by the map may ignore information
+                Some(other_key) => key.hash_stable_eq(other_key),
+                None => false,
+            }
+        })
+    }
+}
+
 impl<K, R, HCX> HashStable<HCX> for ::std::collections::HashSet<K, R>
 where
     K: ToStableHashKey<HCX> + Eq,
diff --git a/compiler/rustc_data_structures/src/tagged_ptr/copy.rs b/compiler/rustc_data_structures/src/tagged_ptr/copy.rs
@@ -1,5 +1,5 @@
 use super::{Pointer, Tag};
-use crate::stable_hasher::{HashStable, StableHasher};
+use crate::stable_hasher::{HashStable, HashStableEq, StableHasher};
 use std::fmt;
 use std::marker::PhantomData;
 use std::num::NonZeroUsize;
@@ -161,6 +161,16 @@ where
 {
 }
 
+impl<P, T> HashStableEq for CopyTaggedPtr<P, T, true>
+where
+    P: Pointer,
+    T: Tag,
+{
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
 impl<P, T> std::hash::Hash for CopyTaggedPtr<P, T, true>
 where
     P: Pointer,
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -2135,7 +2135,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,
 }
diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
@@ -7,7 +7,7 @@ use std::mem;
 use std::ops::{BitAnd, BitAndAssign, BitOrAssign, Bound, Not, Range, RangeBounds, Shl};
 use std::slice;
 
-use rustc_macros::{Decodable, Encodable};
+use rustc_macros::{Decodable, Encodable, HashStableEq};
 
 #[cfg(test)]
 mod tests;
diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs
@@ -53,6 +53,7 @@ impl LintLevelSource {
 pub type LevelAndSource = (Level, LintLevelSource);
 
 #[derive(Debug, HashStable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct LintLevelSets {
     pub list: IndexVec<LintStackIndex, LintSet>,
     pub lint_cap: Level,
@@ -66,6 +67,8 @@ rustc_index::newtype_index! {
 }
 
 #[derive(Debug, HashStable)]
+#[stable_hasher(no_hash_stable_eq)]
+// FIXME - how is LintId implementing HashStable ?
 pub struct LintSet {
     // -A,-W,-D flags, a `Symbol` for the flag itself and `Level` for which
     // flag.
diff --git a/compiler/rustc_middle/src/metadata.rs b/compiler/rustc_middle/src/metadata.rs
@@ -11,6 +11,7 @@ use rustc_span::Span;
 /// Module child can be either a proper item or a reexport (including private imports).
 /// In case of reexport all the fields describe the reexport item itself, not what it refers to.
 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct ModChild {
     /// Name of the item.
     pub ident: Ident,
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -4,6 +4,7 @@ use rustc_span::symbol::Symbol;
 use rustc_target::spec::SanitizerSet;
 
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct CodegenFnAttrs {
     pub flags: CodegenFnAttrFlags,
     /// Parsed representation of the `#[inline]` attribute
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -496,7 +496,7 @@ impl<Tag: Copy, Extra> Allocation<Tag, Extra> {
 }
 
 /// "Relocations" stores the provenance information of pointers stored in memory.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable, HashStableEq)]
 pub struct Relocations<Tag = AllocId>(SortedMap<Size, Tag>);
 
 impl<Tag> Relocations<Tag> {
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -177,7 +177,7 @@ pub enum LitToConstError {
     Reported,
 }
 
-#[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd, HashStableEq)]
 pub struct AllocId(pub NonZeroU64);
 
 // We want the `Debug` output to be readable as it is used by `derive(Debug)` for
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -195,6 +195,7 @@ impl<'tcx> MirSource<'tcx> {
 }
 
 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct GeneratorInfo<'tcx> {
     /// The yield type of the function, if it is a generator.
     pub yield_ty: Option<Ty<'tcx>>,
@@ -212,6 +213,7 @@ pub struct GeneratorInfo<'tcx> {
 
 /// The lowered representation of a single function.
 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct Body<'tcx> {
     /// A list of basic blocks. References to basic block use a newtyped index type [`BasicBlock`]
     /// that indexes into this vector.
@@ -882,6 +884,7 @@ pub struct BlockTailInfo {
 /// This can be a binding declared by the user, a temporary inserted by the compiler, a function
 /// argument, or the return place.
 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct LocalDecl<'tcx> {
     /// Whether this is a mutable binding (i.e., `let x` or `let mut x`).
     ///
@@ -1017,6 +1020,7 @@ static_assert_size!(LocalDecl<'_>, 56);
 /// Not used for non-StaticRef temporaries, the return place, or anonymous
 /// function parameters.
 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum LocalInfo<'tcx> {
     /// A user-defined local variable or function parameter
     ///
diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs
@@ -132,6 +132,7 @@ rustc_index::newtype_index! {
 
 /// The layout of generator state.
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct GeneratorLayout<'tcx> {
     /// The type of every local stored inside the generator.
     pub field_tys: IndexVec<GeneratorSavedLocal, Ty<'tcx>>,
@@ -207,6 +208,7 @@ impl Debug for GeneratorLayout<'_> {
 }
 
 #[derive(Debug, TyEncodable, TyDecodable, HashStable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct BorrowCheckResult<'tcx> {
     /// All the opaque types that are restricted to concrete types
     /// by this function. Unlike the value in `TypeckResults`, this has
diff --git a/compiler/rustc_middle/src/traits/specialization_graph.rs b/compiler/rustc_middle/src/traits/specialization_graph.rs
@@ -22,6 +22,7 @@ use rustc_span::symbol::sym;
 ///   default items amongst other things. In the simple "chain" rule, every impl
 ///   has at most one parent.
 #[derive(TyEncodable, TyDecodable, HashStable, Debug)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct Graph {
     /// All impls have a parent; the "root" impls have as their parent the `def_id`
     /// of the trait.
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
@@ -5,7 +5,7 @@ use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::HashingControls;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::stable_hasher::{HashStable, HashStableEq, StableHasher};
 use rustc_errors::ErrorReported;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
@@ -125,6 +125,12 @@ impl PartialEq for AdtDef {
 
 impl Eq for AdtDef {}
 
+impl HashStableEq for AdtDef {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
 /// There should be only one AdtDef for each `did`, therefore
 /// it is fine to implement `Hash` only based on `did`.
 impl Hash for AdtDef {
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
@@ -111,6 +111,7 @@ impl AssocKind {
 /// it is relatively expensive. Instead, items are indexed by `Symbol` and hygienic comparison is
 /// done only on items with the same name.
 #[derive(Debug, Clone, PartialEq, HashStable)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct AssocItems<'tcx> {
     pub(super) items: SortedIndexMultiMap<u32, Symbol, &'tcx ty::AssocItem>,
 }
diff --git a/compiler/rustc_middle/src/ty/consts/int.rs b/compiler/rustc_middle/src/ty/consts/int.rs
@@ -117,7 +117,8 @@ impl std::fmt::Debug for ConstInt {
 ///
 /// This is a packed struct in order to allow this type to be optimally embedded in enums
 /// (like Scalar).
-#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
+// FIXME - how are these impls correct if HashStable isnt'???
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, HashStableEq)]
 #[repr(packed)]
 pub struct ScalarInt {
     /// The first `size` bytes of `data` are the value.
diff --git a/compiler/rustc_middle/src/ty/fast_reject.rs b/compiler/rustc_middle/src/ty/fast_reject.rs
@@ -17,7 +17,7 @@ pub type SimplifiedType = SimplifiedTypeGen<DefId>;
 /// because we sometimes need to use SimplifiedTypeGen values as stable sorting
 /// keys (in which case we use a DefPathHash as id-type) but in the general case
 /// the non-stable but fast to construct DefId-version is the better choice.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, TyEncodable, TyDecodable)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, TyEncodable, TyDecodable, HashStableEq)]
 pub enum SimplifiedTypeGen<D>
 where
     D: Copy + Debug + Eq,
diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs
@@ -137,8 +137,7 @@ impl<T: PartialEq> PartialEq for List<T> {
 
 impl<T: HashStableEq> HashStableEq for List<T> {
     fn hash_stable_eq(&self, other: &Self) -> bool {
-        // FIXME - is this right?
-        self == other
+        (&self[..]).hash_stable_eq(other)
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -455,7 +455,7 @@ impl<'tcx> PartialEq for TyS<'tcx> {
 impl<'tcx> Eq for TyS<'tcx> {}
 
 impl<'tcx> HashStableEq for TyS<'tcx> {
-    fn hash_stable_eq(&self, other: Self) -> bool {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
         self == other
     }
 }
@@ -1134,7 +1134,7 @@ impl UniverseIndex {
 /// identified by both a universe, as well as a name residing within that universe. Distinct bound
 /// regions/types/consts within the same universe simply have an unknown relationship to one
 /// another.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, PartialOrd, Ord, HashStableEq)]
 pub struct Placeholder<T> {
     pub universe: UniverseIndex,
     pub name: T,
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -2027,7 +2027,6 @@ bitflags::bitflags! {`
`2027`	`2027`	`}`
`2028`	`2028`
`2029`	`2029`	`#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Hash, HashStable_Generic)]`
`2030`		`-#[stable_hasher(no_hash_stable_eq)]`
`2031`	`2030`	`pub enum InlineAsmTemplatePiece {`
`2032`	`2031`	`String(String),`
`2033`	`2032`	`Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },`
Original file line number	Diff line number	Diff line change
`@@ -2135,7 +2135,7 @@ pub enum TraitItemKind<'hir> {`
`2135`	`2135`	`// The bodies for items are stored "out of line", in a separate`
`2136`	`2136`	// hashmap in the `Crate`. Here we just record the hir-id of the item
`2137`	`2137`	`// so it can fetched later.`
`2138`		`-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug)]`
	`2138`	`+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStableEq)]`
`2139`	`2139`	`pub struct ImplItemId {`
`2140`	`2140`	`pub def_id: LocalDefId,`
`2141`	`2141`	`}`