strong hash: Implement for many, many more types

Summary:
Like it says in the title - this makes `strong_hash` available on `BaseDeferredKeyDyn`

Only interesting thing is `bxl/starlark_defs/context/actions.rs`, everything else is straightforward

Reviewed By: IanChilds

Differential Revision: D73628471

fbshipit-source-id: da81889184097a1f9ba10c6bf2522d940680f0fe

Author: JakobDegen

gazebo/strong_hash/Cargo.toml

@@ -7,5 +7,7 @@ repository = { workspace = true }
 version = "0.1.0"
 
 [dependencies]
+num-bigint = { version = "0.4.3", optional = true }
 ref-cast = { workspace = true }
 strong_hash_derive = { workspace = true }
+triomphe = { version = "0.1.8", optional = true }

gazebo/strong_hash/src/impls.rs

@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under both the MIT license found in the
+ * LICENSE-MIT file in the root directory of this source tree and the Apache
+ * License, Version 2.0 found in the LICENSE-APACHE file in the root directory
+ * of this source tree.
+ */
+
+mod num_bigint;
+mod triomphe;

gazebo/strong_hash/src/impls/num_bigint.rs

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under both the MIT license found in the
+ * LICENSE-MIT file in the root directory of this source tree and the Apache
+ * License, Version 2.0 found in the LICENSE-APACHE file in the root directory
+ * of this source tree.
+ */
+
+#![cfg(feature = "num-bigint")]
+use crate as strong_hash;
+
+crate::impl_strong_hash_for_impl_hash!(num_bigint::BigInt);

gazebo/strong_hash/src/impls/triomphe.rs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under both the MIT license found in the
+ * LICENSE-MIT file in the root directory of this source tree and the Apache
+ * License, Version 2.0 found in the LICENSE-APACHE file in the root directory
+ * of this source tree.
+ */
+
+#![cfg(feature = "triomphe")]
+
+use crate::StrongHash;
+
+impl<T: StrongHash + ?Sized> StrongHash for triomphe::Arc<T> {
+    fn strong_hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_ref().strong_hash(state);
+    }
+}

gazebo/strong_hash/src/lib.rs

@@ -11,11 +11,16 @@ use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::hash::Hasher;
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 use ref_cast::RefCast;
 pub use strong_hash_derive::StrongHash;
 
+use crate as strong_hash;
+
+mod impls;
+
 /// `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.
@@ -91,12 +96,13 @@ pub trait StrongHash {
     fn strong_hash<H: Hasher>(&self, state: &mut H);
 }
 
+#[macro_export]
 macro_rules! impl_strong_hash_for_impl_hash {
     ($($t:ty)*) => {
         $(
-            impl StrongHash for $t {
-                fn strong_hash<H: Hasher>(&self, state: &mut H) {
-                    self.hash(state);
+            impl strong_hash::StrongHash for $t {
+                fn strong_hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                    std::hash::Hash::hash(self, state);
                 }
             }
         )*
@@ -202,6 +208,12 @@ impl StrongHash for *const () {
     }
 }
 
+impl<T: ?Sized> StrongHash for PhantomData<T> {
+    fn strong_hash<H: Hasher>(&self, state: &mut H) {
+        self.hash(state);
+    }
+}
+
 /// A wrapper can be used to implement `Hash` using the inner type's `StrongHash`.
 #[derive(RefCast)]
 #[repr(transparent)]

starlark_map/src/ordered_map.rs

@@ -23,6 +23,7 @@ use std::hash::Hash;
 use allocative::Allocative;
 use serde::Deserialize;
 use serde::Serialize;
+use strong_hash::StrongHash;
 
 use crate::Equivalent;
 use crate::small_map;
@@ -201,6 +202,17 @@ impl<K: Hash, V: Hash> Hash for OrderedMap<K, V> {
     }
 }
 
+impl<K: StrongHash, V: StrongHash> StrongHash for OrderedMap<K, V> {
+    #[inline]
+    fn strong_hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.len().strong_hash(state);
+        for (k, v) in self.iter() {
+            k.strong_hash(state);
+            v.strong_hash(state);
+        }
+    }
+}
+
 impl<K: PartialOrd, V: PartialOrd> PartialOrd for OrderedMap<K, V> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {