StrongHash: allow passing in a regular Hasher

Summary:
StrongHash mixes two different concerns:

- Arbitrary output size (StrongHasher).
- Not using precomputed weak hashes (StrongHash).

However, you can want the regular hash output size (aka 64 bits) while not wanting to
use precomputed weak hashes, but right now that's not allowed. This is typically
useful if you are passing your thing to a library that wants a regular 64 bit hash.

This diff fixes that by allowing you to pass a regular `Hasher` into
`fn strong_hash`, and also updates the docs to express the notion that it is OK
to want to use StrongHash even if your hasher isn't a StrongHasher.

Note: ideally you wouldn't want to let someone use a `StrongHasher` and then
pass it into `hash` instead of `strong_hash`, but that was already possible
before, and it doesn't seem like it's been a problem.

Reviewed By: cjhopman

Differential Revision: D73095294

fbshipit-source-id: 80e14308c8547f82b84e25fd20c573f5a98e8cd6

Author: krallin

gazebo/strong_hash/src/lib.rs

@@ -15,9 +15,9 @@ use std::sync::Arc;
 
 pub use strong_hash_derive::StrongHash;
 
-/// `StrongHasher`` is a trait for hashing any type that implements the `StrongHash`
-/// trait. It is similar to `std::hash::Hasher`. The key difference is that `StrongHasher`
-/// produces a vec of bytes as the hash.
+/// `StrongHasher` is a trait for hashing functions that return more than 64
+/// bits of output.  The key difference between `std::hash::Hasher` and
+/// `StrongHasher` is that `StrongHasher` produces a vec of bytes as the hash.
 ///
 /// For example, a `DefaultHasher` implementation of `StrongHasher` is as follows.
 ///
@@ -42,13 +42,16 @@ impl<H: StrongHasher + ?Sized> StrongHasher for &mut H {
         StrongHasher::finish(*self)
     }
 }
-/// `StrongHash`` is a trait for hashing any type that can be hashed. It is similar
-/// to `std::hash::Hash`` except that the hash produced is stored in as a vec of bytes
-/// in `Vec<u8>`` that can accommodate hashing schemes of different lengths.
-/// `StrongHash` is intended to be used with cryptographic hashing algorithms like blake3.
+
+/// `StrongHash`` is a trait that is notionally similar to `std::hash::Hash`,
+/// but carries the implicit expectation that the hash that will be produced
+/// should be as perturbed as possible.
+///
 /// When implementing `StrongHash` for an object, you should always hash the entire object
 /// and not a subset or a lossy representation of the object unless you are hashing another
-/// cryptographic hash of the object.
+/// cryptographic hash of the object. If you do the latter, a good rule of thumb
+/// is that you should feel comfortable also using that same hash for equality
+/// checks.
 ///
 /// By default, `StrongHash` is implemented for most rust types that implement
 /// `std::hash::Hash`. including all primitive types, strings, and vectors.
@@ -84,14 +87,14 @@ impl<H: StrongHasher + ?Sized> StrongHasher for &mut H {
 /// }
 /// ```
 pub trait StrongHash {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H);
+    fn strong_hash<H: Hasher>(&self, state: &mut H);
 }
 
 macro_rules! impl_strong_hash_for_impl_hash {
     ($($t:ty)*) => {
         $(
             impl StrongHash for $t {
-                fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+                fn strong_hash<H: Hasher>(&self, state: &mut H) {
                     self.hash(state);
                 }
             }
@@ -102,7 +105,7 @@ macro_rules! impl_strong_hash_for_impl_hash {
 impl_strong_hash_for_impl_hash!(bool u8 i8 u16 i16 u32 i32 u64 i64 usize str &str String);
 
 impl<T: StrongHash> StrongHash for [T] {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.len().strong_hash(state);
         for item in self.iter() {
             item.strong_hash(state);
@@ -111,20 +114,20 @@ impl<T: StrongHash> StrongHash for [T] {
 }
 
 impl<T: StrongHash> StrongHash for &[T] {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         <[T] as StrongHash>::strong_hash(*self, state);
     }
 }
 
 impl<T: StrongHash> StrongHash for Vec<T> {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.len().strong_hash(state);
         (&self[..]).strong_hash(state);
     }
 }
 
 impl<T: StrongHash> StrongHash for Option<T> {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.is_some().strong_hash(state);
         if let Some(t) = self.as_ref() {
             t.strong_hash(state);
@@ -133,26 +136,26 @@ impl<T: StrongHash> StrongHash for Option<T> {
 }
 
 impl StrongHash for () {
-    fn strong_hash<H: StrongHasher>(&self, _state: &mut H) {}
+    fn strong_hash<H: Hasher>(&self, _state: &mut H) {}
 }
 
 impl<A: StrongHash> StrongHash for (A,) {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         1.strong_hash(state);
         self.0.strong_hash(state);
     }
 }
 
 impl<A: StrongHash, B: StrongHash> StrongHash for (A, B) {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         2.strong_hash(state);
         self.0.strong_hash(state);
         self.1.strong_hash(state);
     }
 }
 
 impl<A: StrongHash, B: StrongHash, C: StrongHash> StrongHash for (A, B, C) {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         3.strong_hash(state);
         self.0.strong_hash(state);
         self.1.strong_hash(state);
@@ -161,19 +164,19 @@ impl<A: StrongHash, B: StrongHash, C: StrongHash> StrongHash for (A, B, C) {
 }
 
 impl<T: StrongHash + ?Sized> StrongHash for Box<T> {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.as_ref().strong_hash(state);
     }
 }
 
 impl<T: StrongHash + ?Sized> StrongHash for Arc<T> {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.as_ref().strong_hash(state);
     }
 }
 
 impl<K: StrongHash, V: StrongHash> StrongHash for BTreeMap<K, V> {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.len().strong_hash(state);
         for (k, v) in self.iter() {
             k.strong_hash(state);
@@ -183,7 +186,7 @@ impl<K: StrongHash, V: StrongHash> StrongHash for BTreeMap<K, V> {
 }
 
 impl<K: StrongHash, V: StrongHash> StrongHash for HashMap<K, V> {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         self.len().strong_hash(state);
         for (k, v) in self.iter() {
             k.strong_hash(state);
@@ -193,7 +196,7 @@ impl<K: StrongHash, V: StrongHash> StrongHash for HashMap<K, V> {
 }
 
 impl StrongHash for *const () {
-    fn strong_hash<H: StrongHasher>(&self, state: &mut H) {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
         (*self as usize).strong_hash(state);
     }
 }

gazebo/strong_hash_derive/src/lib.rs

@@ -26,7 +26,7 @@ pub fn derive_hash(input: TokenStream) -> TokenStream {
             let members = data.fields.members();
             quote! {
                 impl #impl_generics strong_hash::StrongHash for #name #type_generics #where_clause {
-                    fn strong_hash<H: strong_hash::StrongHasher>(&self, state: &mut H) {
+                    fn strong_hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
                         #(StrongHash::strong_hash(&self.#members, state));*
                     }
                 }
@@ -81,7 +81,7 @@ pub fn derive_hash(input: TokenStream) -> TokenStream {
                 .collect::<Vec<_>>();
             quote! {
                 impl #impl_generics strong_hash::StrongHash for #name #type_generics #where_clause {
-                    fn strong_hash<H: strong_hash::StrongHasher>(&self, state: &mut H) {
+                    fn strong_hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
                         match self {
                             #(#hash_impl),*
                         }

starlark_map/src/hashed.rs

@@ -25,7 +25,6 @@ use allocative::Allocative;
 use dupe::Dupe;
 use equivalent::Equivalent;
 use strong_hash::StrongHash;
-use strong_hash::StrongHasher;
 
 use crate::hash_value::StarlarkHashValue;
 
@@ -46,7 +45,7 @@ impl<K> Hash for Hashed<K> {
 }
 
 impl<K: StrongHash> StrongHash for Hashed<K> {
-    fn strong_hash<S: StrongHasher>(&self, state: &mut S) {
+    fn strong_hash<S: Hasher>(&self, state: &mut S) {
         // Only hash the key, not the (weak) hash.
         self.key.strong_hash(state);
     }