Move hashes from rustc_data_structure to rustc_hashes so they can be shared with rust-analyzer

compiler/rustc_data_structures/Cargo.toml

@@ -18,6 +18,7 @@ rustc-rayon = { version = "0.5.1", features = ["indexmap"] }
 rustc-stable-hash = { version = "0.1.0", features = ["nightly"] }
 rustc_arena = { path = "../rustc_arena" }
 rustc_graphviz = { path = "../rustc_graphviz" }
+rustc_hashes = { path = "../rustc_hashes" }
 rustc_index = { path = "../rustc_index", package = "rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }

compiler/rustc_data_structures/src/fingerprint.rs

@@ -1,10 +1,9 @@
 use std::hash::{Hash, Hasher};
 
+use rustc_hashes::Hash64;
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 
-use crate::stable_hasher::{
-    FromStableHash, Hash64, StableHasherHash, impl_stable_traits_for_trivial_type,
-};
+use crate::stable_hasher::{FromStableHash, StableHasherHash, impl_stable_traits_for_trivial_type};
 
 #[cfg(test)]
 mod tests;

compiler/rustc_data_structures/src/hashes.rs

@@ -1,152 +0,0 @@
-//! rustc encodes a lot of hashes. If hashes are stored as `u64` or `u128`, a `derive(Encodable)`
-//! will apply varint encoding to the hashes, which is less efficient than directly encoding the 8
-//! or 16 bytes of the hash.
-//!
-//! The types in this module represent 64-bit or 128-bit hashes produced by a `StableHasher`.
-//! `Hash64` and `Hash128` expose some utility functions to encourage users to not extract the inner
-//! hash value as an integer type and accidentally apply varint encoding to it.
-//!
-//! In contrast with `Fingerprint`, users of these types cannot and should not attempt to construct
-//! and decompose these types into constituent pieces. The point of these types is only to
-//! connect the fact that they can only be produced by a `StableHasher` to their
-//! `Encode`/`Decode` impls.
-
-use std::fmt;
-use std::ops::BitXorAssign;
-
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
-
-use crate::stable_hasher::{FromStableHash, StableHasherHash};
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
-pub struct Hash64 {
-    inner: u64,
-}
-
-impl Hash64 {
-    pub const ZERO: Hash64 = Hash64 { inner: 0 };
-
-    #[inline]
-    pub fn new(n: u64) -> Self {
-        Self { inner: n }
-    }
-
-    #[inline]
-    pub fn as_u64(self) -> u64 {
-        self.inner
-    }
-
-    #[inline]
-    pub fn wrapping_add(self, other: Self) -> Self {
-        Self { inner: self.inner.wrapping_add(other.inner) }
-    }
-}
-
-impl BitXorAssign<u64> for Hash64 {
-    #[inline]
-    fn bitxor_assign(&mut self, rhs: u64) {
-        self.inner ^= rhs;
-    }
-}
-
-impl<S: Encoder> Encodable<S> for Hash64 {
-    #[inline]
-    fn encode(&self, s: &mut S) {
-        s.emit_raw_bytes(&self.inner.to_le_bytes());
-    }
-}
-
-impl<D: Decoder> Decodable<D> for Hash64 {
-    #[inline]
-    fn decode(d: &mut D) -> Self {
-        Self { inner: u64::from_le_bytes(d.read_raw_bytes(8).try_into().unwrap()) }
-    }
-}
-
-impl FromStableHash for Hash64 {
-    type Hash = StableHasherHash;
-
-    #[inline]
-    fn from(StableHasherHash([_0, __1]): Self::Hash) -> Self {
-        Self { inner: _0 }
-    }
-}
-
-impl fmt::Debug for Hash64 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl fmt::LowerHex for Hash64 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::LowerHex::fmt(&self.inner, f)
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct Hash128 {
-    inner: u128,
-}
-
-// We expect Hash128 to be well mixed. So there's no point in hashing both parts.
-//
-// This also allows using Hash128-containing types in UnHash-based hashmaps, which would otherwise
-// debug_assert! that we're hashing more than a single u64.
-impl std::hash::Hash for Hash128 {
-    fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
-        h.write_u64(self.truncate().as_u64());
-    }
-}
-
-impl Hash128 {
-    #[inline]
-    pub fn truncate(self) -> Hash64 {
-        Hash64 { inner: self.inner as u64 }
-    }
-
-    #[inline]
-    pub fn wrapping_add(self, other: Self) -> Self {
-        Self { inner: self.inner.wrapping_add(other.inner) }
-    }
-
-    #[inline]
-    pub fn as_u128(self) -> u128 {
-        self.inner
-    }
-}
-
-impl<S: Encoder> Encodable<S> for Hash128 {
-    #[inline]
-    fn encode(&self, s: &mut S) {
-        s.emit_raw_bytes(&self.inner.to_le_bytes());
-    }
-}
-
-impl<D: Decoder> Decodable<D> for Hash128 {
-    #[inline]
-    fn decode(d: &mut D) -> Self {
-        Self { inner: u128::from_le_bytes(d.read_raw_bytes(16).try_into().unwrap()) }
-    }
-}
-
-impl FromStableHash for Hash128 {
-    type Hash = StableHasherHash;
-
-    #[inline]
-    fn from(StableHasherHash([_0, _1]): Self::Hash) -> Self {
-        Self { inner: u128::from(_0) | (u128::from(_1) << 64) }
-    }
-}
-
-impl fmt::Debug for Hash128 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl fmt::LowerHex for Hash128 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::LowerHex::fmt(&self.inner, f)
-    }
-}

compiler/rustc_data_structures/src/lib.rs

@@ -84,7 +84,6 @@ pub mod vec_cache;
 pub mod work_queue;
 
 mod atomic_ref;
-mod hashes;
 
 /// This calls the passed function while ensuring it won't be inlined into the caller.
 #[inline(never)]

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -10,12 +10,11 @@ use smallvec::SmallVec;
 #[cfg(test)]
 mod tests;
 
+use rustc_hashes::{Hash64, Hash128};
 pub use rustc_stable_hash::{
     FromStableHash, SipHasher128Hash as StableHasherHash, StableSipHasher128 as StableHasher,
 };
 
-pub use crate::hashes::{Hash64, Hash128};
-
 /// Something that implements `HashStable<CTX>` can be hashed in a way that is
 /// stable across multiple compilation sessions.
 ///

compiler/rustc_data_structures/src/tagged_ptr/tests.rs

@@ -1,7 +1,8 @@
 use std::ptr;
 
+use rustc_hashes::Hash128;
+
 use super::*;
-use crate::hashes::Hash128;
 use crate::stable_hasher::{HashStable, StableHasher};
 
 /// A tag type used in [`TaggedRef`] tests.