Simplify PagableDeserialize for unsized types

Summary:
In particular adding:
`impl<'de, T: ?Sized + PagableBoxDeserialize<'de>> PagableDeserialize<'de> for Box<T>`

Which allows a single impl of PagableBoxDeserialize on unsized types to support Box<T> and Arc<T>, which simplifies Pagable impls for str wrapper types in the next diff.

Keeping custom impls for `triomphe::Arc` since I believe creating a box first and passing it to `triomphe::Arc` requires an extra allocation.

Reviewed By: cjhopman

Differential Revision: D92449957

fbshipit-source-id: c751db7a9dc24c70f587dd46abb7684fc781bdc0

Author: christolliday

pagable/src/arc_erase.rs

@@ -222,6 +222,16 @@ pub trait ArcErase: std::any::Any + Sized + Send + Sync + 'static {
     ) -> crate::Result<Self>;
 }
 
+impl WeakErase for () {
+    fn is_expired(&self) -> bool {
+        true
+    }
+
+    fn upgrade_weak(&self) -> Option<Box<dyn ArcEraseDyn>> {
+        None
+    }
+}
+
 impl<T: ?Sized + PagableSerialize + for<'de> PagableBoxDeserialize<'de> + Send + Sync + 'static>
     WeakErase for std::sync::Weak<T>
 {
@@ -265,63 +275,38 @@ impl<T: ?Sized + PagableSerialize + for<'de> PagableBoxDeserialize<'de> + Send +
     }
 }
 
-impl<T: PagableSerialize + for<'de> PagableDeserialize<'de> + Send + Sync + 'static> WeakErase
-    for std::sync::Weak<[T]>
-{
-    fn is_expired(&self) -> bool {
-        self.strong_count() == 0
-    }
-
-    fn upgrade_weak(&self) -> Option<Box<dyn ArcEraseDyn>> {
-        self.upgrade().map(|t| Box::new(t) as _)
-    }
-}
-
 impl<T: PagableSerialize + for<'de> PagableDeserialize<'de> + Send + Sync + 'static> ArcErase
-    for std::sync::Arc<[T]>
+    for triomphe::Arc<T>
 {
-    type Weak = std::sync::Weak<[T]>;
-
+    type Weak = ();
     fn dupe_strong(&self) -> Self {
-        self.dupe()
+        (*self).clone()
     }
 
     fn erase_type() -> impl ArcEraseType {
         StdArcEraseType::<Self>::new()
     }
 
     fn identity(&self) -> usize {
-        Arc::as_ptr(self) as *const T as usize
+        self.as_ptr() as usize
     }
 
-    fn downgrade(&self) -> Option<std::sync::Weak<[T]>> {
-        Some(Arc::downgrade(self))
+    fn downgrade(&self) -> Option<Self::Weak> {
+        None
     }
 
     fn serialize_inner(&self, ser: &mut dyn PagableSerializer) -> crate::Result<()> {
-        <[T] as PagableSerialize>::pagable_serialize(self, ser)
+        T::pagable_serialize(&self, ser)
     }
 
     fn deserialize_inner<'de, D: PagableDeserializer<'de> + ?Sized>(
         deser: &mut D,
     ) -> crate::Result<Self> {
-        Ok(<Box<[T]>>::pagable_deserialize(deser)?.into())
-    }
-}
-
-impl WeakErase for () {
-    fn is_expired(&self) -> bool {
-        true
-    }
-
-    fn upgrade_weak(&self) -> Option<Box<dyn ArcEraseDyn>> {
-        None
+        Ok(Self::new(T::pagable_deserialize(deser)?))
     }
 }
 
-impl<T: PagableSerialize + for<'de> PagableDeserialize<'de> + Send + Sync + 'static> ArcErase
-    for triomphe::Arc<T>
-{
+impl ArcErase for triomphe::Arc<str> {
     type Weak = ();
     fn dupe_strong(&self) -> Self {
         (*self).clone()
@@ -332,21 +317,22 @@ impl<T: PagableSerialize + for<'de> PagableDeserialize<'de> + Send + Sync + 'sta
     }
 
     fn identity(&self) -> usize {
-        self.as_ptr() as usize
+        self.as_ptr() as *const () as usize
     }
 
     fn downgrade(&self) -> Option<Self::Weak> {
         None
     }
 
     fn serialize_inner(&self, ser: &mut dyn PagableSerializer) -> crate::Result<()> {
-        T::pagable_serialize(&self, ser)
+        <str as PagableSerialize>::pagable_serialize(self, ser)
     }
 
     fn deserialize_inner<'de, D: PagableDeserializer<'de> + ?Sized>(
         deser: &mut D,
     ) -> crate::Result<Self> {
-        Ok(Self::new(T::pagable_deserialize(deser)?))
+        let s: String = String::pagable_deserialize(deser)?;
+        Ok(s.into())
     }
 }
 

pagable/src/impls/arc.rs

@@ -57,22 +57,18 @@ impl<
     }
 }
 
-impl<
-    T: PagableSerialize
-        + for<'a> PagableDeserialize<'a>
-        + PagableSerialize
-        + Send
-        + Sync
-        + std::any::Any,
-> PagableSerialize for std::sync::Arc<[T]>
+impl<T: for<'a> PagableDeserialize<'a> + PagableSerialize + Send + Sync + std::any::Any + 'static>
+    PagableSerialize for triomphe::Arc<T>
 {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         serializer.serialize_arc(self)
     }
 }
 
-impl<'de, T: PagableSerialize + for<'a> PagableDeserialize<'a> + Send + Sync + std::any::Any>
-    PagableDeserialize<'de> for std::sync::Arc<[T]>
+impl<
+    'de,
+    T: for<'a> PagableDeserialize<'a> + PagableSerialize + Send + Sync + std::any::Any + 'static,
+> PagableDeserialize<'de> for triomphe::Arc<T>
 {
     fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
         deserializer: &mut D,
@@ -81,22 +77,18 @@ impl<'de, T: PagableSerialize + for<'a> PagableDeserialize<'a> + Send + Sync + s
     }
 }
 
-impl<
-    T: PagableSerialize
-        + for<'a> PagableDeserialize<'a>
-        + PagableSerialize
-        + Send
-        + Sync
-        + std::any::Any,
-> PagableSerialize for triomphe::Arc<T>
+impl<T: for<'a> PagableDeserialize<'a> + PagableSerialize + Send + Sync + std::any::Any + 'static>
+    PagableSerialize for triomphe::Arc<[T]>
 {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         serializer.serialize_arc(self)
     }
 }
 
-impl<'de, T: PagableSerialize + for<'a> PagableDeserialize<'a> + Send + Sync + std::any::Any>
-    PagableDeserialize<'de> for triomphe::Arc<T>
+impl<
+    'de,
+    T: for<'a> PagableDeserialize<'a> + PagableSerialize + Send + Sync + std::any::Any + 'static,
+> PagableDeserialize<'de> for triomphe::Arc<[T]>
 {
     fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
         deserializer: &mut D,
@@ -105,23 +97,13 @@ impl<'de, T: PagableSerialize + for<'a> PagableDeserialize<'a> + Send + Sync + s
     }
 }
 
-impl<
-    T: PagableSerialize
-        + for<'a> PagableDeserialize<'a>
-        + PagableSerialize
-        + Send
-        + Sync
-        + std::any::Any,
-> PagableSerialize for triomphe::Arc<[T]>
-{
+impl PagableSerialize for triomphe::Arc<str> {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         serializer.serialize_arc(self)
     }
 }
 
-impl<'de, T: PagableSerialize + for<'a> PagableDeserialize<'a> + Send + Sync + std::any::Any>
-    PagableDeserialize<'de> for triomphe::Arc<[T]>
-{
+impl<'de> PagableDeserialize<'de> for triomphe::Arc<str> {
     fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
         deserializer: &mut D,
     ) -> crate::Result<Self> {
@@ -152,23 +134,6 @@ impl<
     }
 }
 
-impl PagableSerialize for std::sync::Arc<str> {
-    fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
-        use serde::Serialize;
-        Ok(self.serialize(serializer.serde())?)
-    }
-}
-
-impl<'de> PagableDeserialize<'de> for std::sync::Arc<str> {
-    fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
-        deserializer: &mut D,
-    ) -> crate::Result<Self> {
-        use serde::Deserialize;
-        let v = String::deserialize(deserializer.serde())?;
-        Ok(v.into())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

pagable/src/impls/serde.rs

@@ -62,8 +62,6 @@ use_serde!(bool);
 use_serde!(String);
 use_serde!(Duration);
 
-use_serde!(Box<str>);
-
 impl PagableSerialize for serde_json::Value {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         match self {

pagable/src/impls/std.rs

@@ -105,17 +105,17 @@ impl<'de, T: PagableDeserialize<'de>, E: PagableDeserialize<'de>> PagableDeseria
     }
 }
 
-impl<T: PagableSerialize> PagableSerialize for Box<T> {
+impl<T: ?Sized + PagableSerialize> PagableSerialize for Box<T> {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         (**self).pagable_serialize(serializer)
     }
 }
 
-impl<'de, T: PagableDeserialize<'de>> PagableDeserialize<'de> for Box<T> {
+impl<'de, T: ?Sized + PagableBoxDeserialize<'de>> PagableDeserialize<'de> for Box<T> {
     fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
         deserializer: &mut D,
     ) -> crate::Result<Self> {
-        Ok(Box::new(T::pagable_deserialize(deserializer)?))
+        T::deserialize_box(deserializer)
     }
 }
 
@@ -138,16 +138,10 @@ impl<T: PagableSerialize> PagableSerialize for [T] {
     }
 }
 
-impl<T: PagableSerialize> PagableSerialize for Box<[T]> {
-    fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
-        <[T] as PagableSerialize>::pagable_serialize(&**self, serializer)
-    }
-}
-
-impl<'de, T: PagableDeserialize<'de>> PagableDeserialize<'de> for Box<[T]> {
-    fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
+impl<'de, T: PagableDeserialize<'de>> PagableBoxDeserialize<'de> for [T] {
+    fn deserialize_box<D: PagableDeserializer<'de> + ?Sized>(
         deserializer: &mut D,
-    ) -> crate::Result<Self> {
+    ) -> crate::Result<Box<Self>> {
         let items = usize::deserialize(deserializer.serde())?;
         let mut v = Vec::with_capacity(items);
         for _ in 0..items {
@@ -175,6 +169,21 @@ impl<'de> PagableDeserialize<'de> for AtomicI64 {
     }
 }
 
+impl PagableSerialize for str {
+    fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
+        Ok(self.serialize(serializer.serde())?)
+    }
+}
+
+impl<'de> PagableBoxDeserialize<'de> for str {
+    fn deserialize_box<D: PagableDeserializer<'de> + ?Sized>(
+        deserializer: &mut D,
+    ) -> crate::Result<Box<Self>> {
+        let s = String::deserialize(deserializer.serde())?;
+        Ok(s.into_boxed_str())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;