Get rustc_middle compiling

Author: Aaron1011

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 },

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 },

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;

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,

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,

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,
 }

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;

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.

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,

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