strong_hash: allow requesting that Hash use the StrongHash through a type wrapper

Summary:
The goal of this is to allow you to take something that implements
`StrongHash`, pass it to something that expects `Hash` and yet have it use the
`StrongHash` implementation (but not the `StrongHasher::finish`: since your
callee wants to `Hash` it'll have to accept it only gets 64 bits worth of
hash).

Reviewed By: cjhopman, scottcao

Differential Revision: D73095295

fbshipit-source-id: 238f0c9b8d6b26bec9a0bc4ef8df86e8163406e2

Author: krallin

Cargo.toml

@@ -43,4 +43,5 @@ indenter = "0.3.3"
 memchr = "2.4.1"
 proc-macro2 = "1.0"
 quote = "1.0.3"
+ref-cast = "1.0.0"
 syn = "2"

gazebo/strong_hash/Cargo.toml

@@ -7,4 +7,5 @@ repository = { workspace = true }
 version = "0.1.0"
 
 [dependencies]
+ref-cast = { workspace = true }
 strong_hash_derive = { workspace = true }

gazebo/strong_hash/src/lib.rs

@@ -13,6 +13,7 @@ use std::hash::Hash;
 use std::hash::Hasher;
 use std::sync::Arc;
 
+use ref_cast::RefCast;
 pub use strong_hash_derive::StrongHash;
 
 /// `StrongHasher` is a trait for hashing functions that return more than 64
@@ -200,3 +201,73 @@ impl StrongHash for *const () {
         (*self as usize).strong_hash(state);
     }
 }
+
+/// A wrapper can be used to implement `Hash` using the inner type's `StrongHash`.
+#[derive(RefCast)]
+#[repr(transparent)]
+pub struct UseStrongHashing<T: ?Sized>(pub T);
+
+impl<T> Hash for UseStrongHashing<T>
+where
+    T: ?Sized + StrongHash,
+{
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.strong_hash(state);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    struct TestHashable {
+        hash: u64,
+        strong_hash: u64,
+    }
+
+    impl Hash for TestHashable {
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            self.hash.hash(state);
+        }
+    }
+
+    impl StrongHash for TestHashable {
+        fn strong_hash<H: Hasher>(&self, state: &mut H) {
+            self.strong_hash.strong_hash(state);
+        }
+    }
+
+    fn hash<T: Hash>(t: &T) -> u64 {
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        t.hash(&mut hasher);
+        hasher.finish()
+    }
+
+    fn strong_hash<T: StrongHash>(t: &T) -> u64 {
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        t.strong_hash(&mut hasher);
+        hasher.finish()
+    }
+
+    #[test]
+    fn test_use_strong_hashing() {
+        let x = TestHashable {
+            hash: 1,
+            strong_hash: 2,
+        };
+
+        let y = TestHashable {
+            hash: 1,
+            strong_hash: 3,
+        };
+
+        assert_eq!(hash(&x), hash(&y));
+
+        assert_eq!(strong_hash(&x), hash(UseStrongHashing::ref_cast(&x)));
+
+        assert_ne!(
+            hash(UseStrongHashing::ref_cast(&x)),
+            hash(UseStrongHashing::ref_cast(&y))
+        );
+    }
+}