Support multiple hasher

Author: Urgau

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Unreleased
 
+- Introduce multi hasher support (#8)
 - `StableHasher::finish` now returns a small hash instead of being fatal (#6)
 - Remove `StableHasher::finalize` (#4)
 - Import stable hasher implementation from rustc ([db8aca48129](https://github.com/rust-lang/rust/blob/db8aca48129d86b2623e3ac8cbcf2902d4d313ad/compiler/rustc_data_structures/src/))

src/lib.rs

@@ -11,3 +11,11 @@ pub use stable_hasher::StableHasher;
 
 #[doc(inline)]
 pub use stable_hasher::StableHasherResult;
+
+#[doc(inline)]
+pub use stable_hasher::ExtendedHasher;
+
+pub use sip128::SipHasher128; // TODO: Should SipHasher128 be exposed?
+
+/// Stable Sip Hasher 128
+pub type StableSipHasher128 = StableHasher<SipHasher128>;

src/sip128.rs

@@ -3,6 +3,7 @@
 // This code is very hot and uses lots of arithmetic, avoid overflow checks for performance.
 // See https://github.com/rust-lang/rust/pull/119440#issuecomment-1874255727
 use crate::int_overflow::{DebugStrictAdd, DebugStrictSub};
+use crate::ExtendedHasher;
 
 use std::hash::Hasher;
 use std::mem::{self, MaybeUninit};
@@ -214,28 +215,6 @@ impl SipHasher128 {
         hasher
     }
 
-    #[inline]
-    pub fn short_write<const LEN: usize>(&mut self, bytes: [u8; LEN]) {
-        let nbuf = self.nbuf;
-        debug_assert!(LEN <= 8);
-        debug_assert!(nbuf < BUFFER_SIZE);
-        debug_assert!(nbuf + LEN < BUFFER_WITH_SPILL_SIZE);
-
-        if nbuf.debug_strict_add(LEN) < BUFFER_SIZE {
-            unsafe {
-                // The memcpy call is optimized away because the size is known.
-                let dst = (self.buf.as_mut_ptr() as *mut u8).add(nbuf);
-                ptr::copy_nonoverlapping(bytes.as_ptr(), dst, LEN);
-            }
-
-            self.nbuf = nbuf.debug_strict_add(LEN);
-
-            return;
-        }
-
-        unsafe { self.short_write_process_buffer(bytes) }
-    }
-
     // A specialized write function for values with size <= 8 that should only
     // be called when the write would cause the buffer to fill.
     //
@@ -378,13 +357,8 @@ impl SipHasher128 {
         }
     }
 
-    #[inline(always)]
-    pub fn finish128(mut self) -> [u64; 2] {
-        SipHasher128::finish128_inner(self.nbuf, &mut self.buf, self.state, self.processed)
-    }
-
     #[inline]
-    fn finish128_inner(
+    unsafe fn finish128_inner(
         nbuf: usize,
         buf: &mut [MaybeUninit<u64>; BUFFER_WITH_SPILL_CAPACITY],
         mut state: State,
@@ -437,6 +411,45 @@ impl SipHasher128 {
     }
 }
 
+impl Default for SipHasher128 {
+    fn default() -> SipHasher128 {
+        SipHasher128::new_with_keys(0, 0)
+    }
+}
+
+impl ExtendedHasher for SipHasher128 {
+    type Hash = [u64; 2];
+
+    #[inline]
+    fn short_write<const LEN: usize>(&mut self, bytes: [u8; LEN]) {
+        let nbuf = self.nbuf;
+        debug_assert!(LEN <= 8);
+        debug_assert!(nbuf < BUFFER_SIZE);
+        debug_assert!(nbuf + LEN < BUFFER_WITH_SPILL_SIZE);
+
+        if nbuf.debug_strict_add(LEN) < BUFFER_SIZE {
+            unsafe {
+                // The memcpy call is optimized away because the size is known.
+                let dst = (self.buf.as_mut_ptr() as *mut u8).add(nbuf);
+                ptr::copy_nonoverlapping(bytes.as_ptr(), dst, LEN);
+            }
+
+            self.nbuf = nbuf.debug_strict_add(LEN);
+
+            return;
+        }
+
+        unsafe { self.short_write_process_buffer(bytes) }
+    }
+
+    #[inline(always)]
+    fn finish(mut self) -> [u64; 2] {
+        unsafe {
+            SipHasher128::finish128_inner(self.nbuf, &mut self.buf, self.state, self.processed)
+        }
+    }
+}
+
 impl Hasher for SipHasher128 {
     #[inline]
     fn write_u8(&mut self, i: u8) {
@@ -504,7 +517,9 @@ impl Hasher for SipHasher128 {
 
     fn finish(&self) -> u64 {
         let mut buf = self.buf.clone();
-        let [a, b] = SipHasher128::finish128_inner(self.nbuf, &mut buf, self.state, self.processed);
+        let [a, b] = unsafe {
+            SipHasher128::finish128_inner(self.nbuf, &mut buf, self.state, self.processed)
+        };
 
         // Combining the two halves makes sure we get a good quality hash.
         a.wrapping_mul(3).wrapping_add(b).to_le()

src/sip128/tests.rs

@@ -16,7 +16,7 @@ impl<'a> Hash for Bytes<'a> {
 
 fn hash_with<T: Hash>(mut st: SipHasher128, x: &T) -> [u64; 2] {
     x.hash(&mut st);
-    st.finish128()
+    st.finish()
 }
 
 fn hash<T: Hash>(x: &T) -> [u64; 2] {
@@ -253,8 +253,8 @@ fn test_short_write_works() {
     h2.write(&test_i128.to_ne_bytes());
     h2.write(&test_isize.to_ne_bytes());
 
-    let h1_hash = h1.finish128();
-    let h2_hash = h2.finish128();
+    let h1_hash = h1.finish();
+    let h2_hash = h2.finish();
 
     assert_eq!(h1_hash, h2_hash);
 }
@@ -279,8 +279,8 @@ macro_rules! test_fill_buffer {
             h2.write(s);
             h2.write(x_bytes);
 
-            let h1_hash = h1.finish128();
-            let h2_hash = h2.finish128();
+            let h1_hash = h1.finish();
+            let h2_hash = h2.finish();
 
             assert_eq!(h1_hash, h2_hash);
         }
@@ -306,10 +306,14 @@ fn test_fill_buffer() {
 
 #[test]
 fn test_finish() {
+    fn hash<H: Hasher>(h: &H) -> u64 {
+        h.finish()
+    }
+
     let mut hasher = SipHasher128::new_with_keys(0, 0);
 
     hasher.write_isize(0xF0);
     hasher.write_isize(0xF0010);
 
-    assert_eq!(hasher.finish(), hasher.finish());
+    assert_eq!(hash(&hasher), hash(&hasher));
 }

src/stable_hasher.rs

@@ -1,13 +1,59 @@
 //! Stable hasher adapted for cross-platform independent hash.
 
-use crate::sip128::SipHasher128;
-
 use std::fmt;
 use std::hash::Hasher;
 
 #[cfg(test)]
 mod tests;
 
+/// Extended the [`Hasher`] trait for use with [`StableHasher`].
+///
+/// It permits returning an arbitrary type as the [`Self::Hash`] type
+/// contrary to the [`Hasher`] trait which can only return `u64`. This
+/// is useful when the hasher uses a different representation.
+///
+/// # Example
+///
+/// ```
+/// use std::hash::Hasher;
+/// use rustc_stable_hash::ExtendedHasher;
+///
+/// struct DumbHasher(u128);
+///
+/// impl Hasher for DumbHasher {
+///     fn write(&mut self, a: &[u8]) {
+///         # self.0 = a.iter().fold(0u128, |acc, a| acc + (*a as u128)) + self.0;
+///         // ...
+///     }
+///
+///     fn finish(&self) -> u64 {
+///         self.0 as u64 // really dumb
+///     }
+/// }
+///
+/// impl ExtendedHasher for DumbHasher {
+///     type Hash = u128;
+///
+///     fn short_write<const LEN: usize>(&mut self, bytes: [u8; LEN]) {
+///         self.write(&bytes)
+///     }
+///
+///     fn finish(self) -> Self::Hash {
+///         self.0
+///     }
+/// }
+/// ```
+pub trait ExtendedHasher: Hasher {
+    /// Type returned by the hasher.
+    type Hash;
+
+    /// Optimized version of [`Hasher::write`] but for small write.
+    fn short_write<const LEN: usize>(&mut self, bytes: [u8; LEN]);
+
+    /// Finalization method of the hasher to return the [`Hash`].
+    fn finish(self) -> Self::Hash;
+}
+
 /// A Stable Hasher adapted for cross-platform independent hash.
 ///
 /// When hashing something that ends up affecting properties like symbol names,
@@ -21,24 +67,26 @@ mod tests;
 /// # Example
 ///
 /// ```
-/// use rustc_stable_hash::{StableHasher, StableHasherResult};
+/// use rustc_stable_hash::{StableHasher, StableHasherResult, StableSipHasher128};
 /// use std::hash::Hasher;
 ///
 /// struct Hash128([u64; 2]);
 /// impl StableHasherResult for Hash128 {
+///     type Hash = [u64; 2];
+///
 ///     fn finish(hash: [u64; 2]) -> Hash128 {
 ///         Hash128(hash)
 ///     }
 /// }
 ///
-/// let mut hasher = StableHasher::new();
+/// let mut hasher = StableSipHasher128::new();
 /// hasher.write_usize(0xFA);
 ///
 /// let hash: Hash128 = hasher.finish();
 /// ```
 #[must_use]
-pub struct StableHasher {
-    state: SipHasher128,
+pub struct StableHasher<H: ExtendedHasher> {
+    state: H,
 }
 
 /// Trait for retrieving the result of the stable hashing operation.
@@ -51,6 +99,8 @@ pub struct StableHasher {
 /// struct Hash128(u128);
 ///
 /// impl StableHasherResult for Hash128 {
+///     type Hash = [u64; 2];
+///
 ///     fn finish(hash: [u64; 2]) -> Hash128 {
 ///         let upper: u128 = hash[0] as u128;
 ///         let lower: u128 = hash[1] as u128;
@@ -60,23 +110,36 @@ pub struct StableHasher {
 /// }
 /// ```
 pub trait StableHasherResult: Sized {
+    type Hash;
+
     /// Retrieving the finalized state of the [`StableHasher`] and construct
     /// an [`Self`] containing the hash.
-    fn finish(hasher: [u64; 2]) -> Self;
+    fn finish(hash: Self::Hash) -> Self;
 }
 
-impl StableHasher {
+impl<H: ExtendedHasher + Default> StableHasher<H> {
     /// Creates a new [`StableHasher`].
     ///
     /// To be used with the [`Hasher`] implementation and [`StableHasher::finish`].
+    // TODO: Should this exist as is? or maybe it should take an `ExtendedHasher` as input?
     #[inline]
     #[must_use]
     pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl<H: ExtendedHasher + Default> Default for StableHasher<H> {
+    #[inline]
+    #[must_use]
+    fn default() -> Self {
         StableHasher {
-            state: SipHasher128::new_with_keys(0, 0),
+            state: Default::default(),
         }
     }
+}
 
+impl<H: ExtendedHasher> StableHasher<H> {
     /// Returns the typed-hash value for the values written.
     ///
     /// The resulting typed-hash value is constructed from an
@@ -85,23 +148,23 @@ impl StableHasher {
     /// To be used in-place of [`Hasher::finish`].
     #[inline]
     #[must_use]
-    pub fn finish<W: StableHasherResult>(self) -> W {
-        W::finish(self.state.finish128())
+    pub fn finish<W: StableHasherResult<Hash = H::Hash>>(self) -> W {
+        W::finish(self.state.finish())
     }
 }
 
-impl fmt::Debug for StableHasher {
+impl<H: ExtendedHasher + fmt::Debug> fmt::Debug for StableHasher<H> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}", self.state)
     }
 }
 
-impl Hasher for StableHasher {
+impl<H: ExtendedHasher> Hasher for StableHasher<H> {
     /// Returns a combined hash.
     ///
     /// For greater precision use instead [`StableHasher::finish`].
     fn finish(&self) -> u64 {
-        self.state.finish()
+        Hasher::finish(&self.state)
     }
 
     #[inline]
@@ -192,7 +255,7 @@ impl Hasher for StableHasher {
         // Cold path
         #[cold]
         #[inline(never)]
-        fn hash_value(state: &mut SipHasher128, value: u64) {
+        fn hash_value<H: ExtendedHasher>(state: &mut H, value: u64) {
             state.write_u8(0xFF);
             state.short_write(value.to_le_bytes());
         }