Implement Pagable for some leaf types

Summary: Implement/derive pagable for some external types and simple types that buck2 types depend on.

Reviewed By: cjhopman

Differential Revision: D89434554

fbshipit-source-id: 4c2991e46cd790bb9d8ba63020021c41085da47a

Author: christolliday

Cargo.toml

@@ -2,10 +2,13 @@
 members = [
     "allocative/allocative",
     "allocative/allocative_derive",
+    "gazebo/gazebo",
     "gazebo/display_container",
     "gazebo/dupe",
     "gazebo/strong_hash",
     "gazebo/strong_hash_derive",
+    "pagable",
+    "pagable_derive",
     "starlark",
     "starlark_bin",
     "starlark_derive",
@@ -26,6 +29,7 @@ allocative_derive = { version = "0.3.3", path = "allocative/allocative_derive" }
 cmp_any = { version = "0.8.1", path = "gazebo/cmp_any" }
 display_container = { version = "0.9.0", path = "gazebo/display_container" }
 dupe = { version = "0.9.1", path = "gazebo/dupe" }
+gazebo = { path = "gazebo/gazebo" }
 strong_hash = { path = "gazebo/strong_hash" }
 strong_hash_derive = { path = "gazebo/strong_hash_derive" }
 
@@ -44,4 +48,20 @@ memchr = "2.4.1"
 proc-macro2 = "1.0"
 quote = "1.0.3"
 ref-cast = "1.0.0"
+relative-path = { version = "1.7.0", features = ["serde"] }
 syn = "2"
+
+pagable = { path = "pagable" }
+pagable_derive = { path = "pagable_derive" }
+# dependencies of pagable
+async-trait = "0.1.24"
+blake3 = { version = "1.3.1", features = ["default", "rayon", "std", "traits-preview"] }
+bytemuck = { version = "1.24", features = ["const_zeroed", "derive", "min_const_generics", "must_cast", "nightly_stdsimd"] }
+parking_lot = { version = "0.11.2", features = ["send_guard"] }
+postcard = { version = "1.0.8", features = ["use-crc", "use-std"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = { version = "1.0.48", features = ["raw_value"] }
+static_assertions = "1.1.0"
+take_mut = "0.2.2"
+tokio = { version = "1.25.0", features = ["full", "test-util", "tracing"] }
+triomphe = "0.1.11"

pagable/Cargo.toml

@@ -14,9 +14,10 @@ bytemuck = { workspace = true }
 dupe = { workspace = true }
 either = { workspace = true }
 gazebo = { workspace = true }
-pagable_derive = { workspace = true }
+pagable_derive = { path = "../pagable_derive" }
 parking_lot = { workspace = true }
 postcard = { workspace = true }
+relative-path = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 static_assertions = { workspace = true }

pagable/src/impls.rs

@@ -13,3 +13,28 @@ mod collections;
 mod serde;
 mod std;
 mod tuples;
+
+use relative_path::RelativePathBuf;
+
+use crate::__internal::serde::Deserialize;
+use crate::__internal::serde::Serializer;
+use crate::PagableDeserialize;
+use crate::PagableDeserializer;
+use crate::PagableSerialize;
+use crate::PagableSerializer;
+
+impl PagableSerialize for RelativePathBuf {
+    fn pagable_serialize<S: PagableSerializer>(&self, serializer: &mut S) -> crate::Result<()> {
+        Ok(serializer.serde().serialize_str(self.as_str())?)
+    }
+}
+
+impl<'de> PagableDeserialize<'de> for RelativePathBuf {
+    fn pagable_deserialize<D: PagableDeserializer<'de>>(
+        deserializer: &mut D,
+    ) -> crate::Result<Self> {
+        Ok(RelativePathBuf::from(String::deserialize(
+            deserializer.serde(),
+        )?))
+    }
+}

pagable/src/impls/std.rs

@@ -8,6 +8,8 @@
  * above-listed licenses.
  */
 
+use core::sync::atomic::AtomicI64;
+
 use ::serde::Deserialize;
 use ::serde::ser::Serialize;
 
@@ -114,3 +116,21 @@ impl<'de, T: PagableDeserialize<'de>> PagableDeserialize<'de> for Box<[T]> {
         Ok(v.into_boxed_slice())
     }
 }
+
+impl PagableSerialize for AtomicI64 {
+    fn pagable_serialize<S: PagableSerializer>(&self, serializer: &mut S) -> crate::Result<()> {
+        Ok(i64::serialize(
+            &self.load(core::sync::atomic::Ordering::Relaxed),
+            serializer.serde(),
+        )?)
+    }
+}
+
+impl<'de> PagableDeserialize<'de> for AtomicI64 {
+    fn pagable_deserialize<D: PagableDeserializer<'de>>(
+        deserializer: &mut D,
+    ) -> crate::Result<Self> {
+        let val = i64::deserialize(deserializer.serde())?;
+        Ok(AtomicI64::new(val))
+    }
+}

pagable/src/lib.rs

@@ -18,8 +18,6 @@
 //! Implementations can use the derive macros `#[derive(Pagable)]` (which will derive both serialize and deserialize), `#[derive(PagableSerialize)]`,
 //! and `#[derive(PagableDeserialize)]` for automatic implementations.
 
-#![feature(const_type_name)]
-
 pub use pagable_arc::PagableArc;
 pub use pagable_arc::PinnedPagableArc;
 pub use pagable_arc::PinnedPagableArcBorrow;

starlark_map/Cargo.toml

@@ -10,6 +10,10 @@ name = "starlark_map"
 repository = "https://github.com/facebook/starlark-rust"
 version = "0.13.0"
 
+[features]
+default = []
+pagable = ["dep:pagable", "dep:pagable_derive"]
+
 [dependencies]
 allocative = { workspace = true, features = ["hashbrown"] }
 dupe = { workspace = true }
@@ -18,6 +22,9 @@ equivalent = { workspace = true }
 fxhash = "0.2.1"
 hashbrown = { version = "0.14.3", features = ["raw"] }
 serde = { version = "1.0", features = ["derive"] }
+
+pagable = { workspace = true, optional = true }
+pagable_derive = { workspace = true, optional = true }
 strong_hash = { workspace = true }
 
 [dev-dependencies]

starlark_map/src/hash_value.rs

@@ -20,12 +20,28 @@ use std::hash::Hash;
 
 use allocative::Allocative;
 use dupe::Dupe;
+#[cfg(feature = "pagable")]
+use pagable::Pagable;
+use serde::Deserialize;
+use serde::Serialize;
 
 use crate::hasher::StarlarkHasher;
 use crate::mix_u32::mix_u32;
 
 /// A hash value.
-#[derive(Clone, Copy, Dupe, PartialEq, Eq, Hash, Debug, Allocative)]
+#[derive(
+    Clone,
+    Copy,
+    Dupe,
+    PartialEq,
+    Eq,
+    Hash,
+    Debug,
+    Allocative,
+    Serialize,
+    Deserialize
+)]
+#[cfg_attr(feature = "pagable", derive(Pagable))]
 pub struct StarlarkHashValue(u32);
 
 impl StarlarkHashValue {

starlark_map/src/hashed.rs

@@ -24,12 +24,28 @@ use std::ops::Deref;
 use allocative::Allocative;
 use dupe::Dupe;
 use equivalent::Equivalent;
+#[cfg(feature = "pagable")]
+use pagable::Pagable;
+use serde::Deserialize;
+use serde::Serialize;
 use strong_hash::StrongHash;
 
 use crate::hash_value::StarlarkHashValue;
 
 /// A key and its hash.
-#[derive(PartialEq, Eq, Debug, Clone, Copy, Dupe, Allocative)]
+#[derive(
+    PartialEq,
+    Eq,
+    Debug,
+    Clone,
+    Copy,
+    Dupe,
+    Allocative,
+    Serialize,
+    Deserialize
+)]
+#[cfg_attr(feature = "pagable", derive(Pagable))]
+#[cfg_attr(feature = "pagable", pagable(bound = "K: Pagable + 'static"))]
 pub struct Hashed<K> {
     hash: StarlarkHashValue,
     key: K,

starlark_map/src/ordered_map.rs

@@ -21,6 +21,8 @@ use std::cmp::Ordering;
 use std::hash::Hash;
 
 use allocative::Allocative;
+#[cfg(feature = "pagable")]
+use pagable::Pagable;
 use serde::Deserialize;
 use serde::Serialize;
 use strong_hash::StrongHash;
@@ -31,6 +33,7 @@ use crate::small_map::SmallMap;
 
 /// Wrapper for `SmallMap` which considers map equal if iteration order is equal.
 #[derive(Debug, Clone, Allocative)]
+#[cfg_attr(feature = "pagable", derive(Pagable))]
 pub struct OrderedMap<K, V>(SmallMap<K, V>);
 
 impl<K, V> OrderedMap<K, V> {

starlark_map/src/ordered_set.rs

@@ -21,14 +21,20 @@ use std::cmp::Ordering;
 use std::hash::Hash;
 
 use allocative::Allocative;
+#[cfg(feature = "pagable")]
+use pagable::Pagable;
+use serde::Deserialize;
+use serde::Serialize;
 
 use crate::Equivalent;
 use crate::Hashed;
 use crate::small_set;
 use crate::small_set::SmallSet;
 
 /// `SmallSet` wrapper, but equality and hash of self depends on iteration order.
-#[derive(Debug, Clone, Allocative)]
+#[derive(Debug, Clone, Allocative, Serialize, Deserialize)]
+#[cfg_attr(feature = "pagable", derive(Pagable))]
+#[serde(bound(deserialize = "T: Deserialize<'de> + Hash + Eq"))]
 pub struct OrderedSet<T>(SmallSet<T>);
 
 /// Error returned by `try_insert`.