Drop partial ser/de support

Author: nbdd0121

Cargo.Bazel.lock

@@ -1,5 +1,5 @@
 {
-  "checksum": "fb64f56ffe49bf513c5c452aa608fee4b8bb1d9c1c9448e0a898baa7b7db8294",
+  "checksum": "30966b16f4d4befb4a3d4e8958940a723b5bb9d99bb61475a460e972be60014c",
   "crates": {
     "aho-corasick 1.1.3": {
       "name": "aho-corasick",
@@ -2193,10 +2193,6 @@
             {
               "id": "thiserror 1.0.58",
               "target": "thiserror"
-            },
-            {
-              "id": "typeid 1.0.3",
-              "target": "typeid"
             }
           ],
           "selects": {}

Cargo.lock

@@ -50,7 +50,6 @@ rust_library(
         "@crate_index//:scopeguard",
         "@crate_index//:serde",
         "@crate_index//:thiserror",
-        "@crate_index//:typeid",
     ],
 )
 

serde_annotate/BUILD.bazel

@@ -8,7 +8,6 @@ anstyle = "1.0"
 thiserror = "1.0"
 num-traits = "0.2.15"
 serde = "1.0"
-typeid = "1"
 once_cell = "1.12"
 serde_annotate_derive = {path = "../serde_annotate_derive"}
 pest = "2.2"

serde_annotate/Cargo.toml

@@ -1,7 +1,3 @@
-use std::fmt;
-
-use crate::{AnnotatedSerializer, Document, Error};
-
 /// Specifies the formatting options to use when serializing.
 pub enum Format {
     /// Format a string in block/multiline style.
@@ -31,40 +27,9 @@ pub enum MemberId<'a> {
     Variant,
 }
 
-/// Trait indicating a type can be serialized by `AnnotatedSerialize`.
-///
-/// This is specialized version of `Serialize` trait that operates only on `AnnotatedSerializer`,
-/// so it is dyn-safe.
-pub trait AnnotateSerialize {
-    fn annotated_serialize(&self, serializer: &mut AnnotatedSerializer) -> Result<Document, Error>;
-}
-
-impl<T: serde::Serialize + ?Sized> AnnotateSerialize for T {
-    fn annotated_serialize(&self, serializer: &mut AnnotatedSerializer) -> Result<Document, Error> {
-        self.serialize(serializer)
-    }
-}
-
-impl serde::Serialize for dyn AnnotateSerialize {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        AnnotatedSerializer::specialize(serializer, |serializer| {
-            self.annotated_serialize(serializer)
-        })
-    }
-}
-
-impl fmt::Debug for dyn AnnotateSerialize {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "dyn AnnotateSerialize({:p})", self)
-    }
-}
-
 /// Trait implemented on structs to inform the serializer about formatting
 /// options and comments.
-pub trait Annotate: AnnotateSerialize {
+pub trait Annotate {
     fn format(&self, variant: Option<&str>, field: &MemberId) -> Option<Format>;
     fn comment(&self, variant: Option<&str>, field: &MemberId) -> Option<String>;
 }

serde_annotate/src/annotate.rs

@@ -1,7 +1,5 @@
 // Deserializer for serde-annotate `Document`s.
 
-use std::mem::ManuallyDrop;
-
 use serde::de::{
     self, DeserializeOwned, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
     VariantAccess, Visitor,
@@ -71,32 +69,6 @@ impl<'de> Deserializer<'de> {
             doc: doc.as_value()?,
         })
     }
-
-    /// Try to convert a generic `Serializer` into `Self`.
-    pub fn try_specialize<D: serde::Deserializer<'de>, T>(
-        deserializer: D,
-        ok: impl FnOnce(&mut Self) -> Result<T>,
-        err: impl FnOnce(D) -> Result<T, D::Error>,
-    ) -> Result<T, D::Error> {
-        if typeid::of::<D>() == typeid::of::<&mut Self>() {
-            // SAFETY: If `deserializer` is the correct type, then we can transmute the
-            // reference into `&mut Deserializer`.
-            //
-            // For the lifetime, we observe that the lifetime on `ok` works for any lifetime.
-            // So the exact lifetime on the `&mut` would not matter for the soundness.
-            // We observe that `D: Deserializer<'de>`, so we can infer that `'d` is correct for
-            // the lifetime parameter.
-            let deserializer: &mut Self =
-                unsafe { std::mem::transmute_copy(&ManuallyDrop::new(deserializer)) };
-
-            let r = ok(deserializer);
-
-            // SAFETY: Similarly, we can transmute the return value.
-            unsafe { std::mem::transmute_copy(&ManuallyDrop::new(r)) }
-        } else {
-            err(deserializer)
-        }
-    }
 }
 
 /// Parses and deserializes a `str` into a `T`.  The parser is

serde_annotate/src/de.rs

@@ -7,12 +7,11 @@ mod error;
 mod hexdump;
 mod integer;
 mod json;
-mod partial;
 mod relax;
 mod ser;
 mod yaml;
 
-pub use annotate::{Annotate, AnnotateSerialize};
+pub use annotate::Annotate;
 pub use color::ColorProfile;
 pub use de::{from_str, Deserialize, Deserializer};
 pub use doc_iter::DocPath;

serde_annotate/src/lib.rs

@@ -1,5 +1,4 @@
 use std::cell::Cell;
-use std::mem::ManuallyDrop;
 
 use serde::ser;
 
@@ -39,30 +38,6 @@ impl AnnotatedSerializer {
         }
     }
 
-    /// Try to convert a generic `Serializer` into `Self`.
-    pub fn try_specialize<S: serde::Serializer>(
-        serializer: S,
-        ok: impl FnOnce(&mut AnnotatedSerializer) -> Result<Document, Error>,
-        err: impl FnOnce(S) -> Result<S::Ok, S::Error>,
-    ) -> Result<S::Ok, S::Error> {
-        if typeid::of::<S>() == typeid::of::<&mut AnnotatedSerializer>() {
-            // SAFETY: If `serializer` is the correct type, then we can transmute the
-            // reference into `&mut AnnotatedSerializer`.
-            //
-            // For the lifetime, we observe that the lifetime on `ok` works for any lifetime.
-            // So the exact lifetime would not matter for the soundness.
-            let serializer: &mut AnnotatedSerializer =
-                unsafe { std::mem::transmute_copy(&ManuallyDrop::new(serializer)) };
-
-            let r = ok(serializer);
-
-            // SAFETY: Similarly, we can transmute the return value.
-            unsafe { std::mem::transmute_copy(&ManuallyDrop::new(r)) }
-        } else {
-            err(serializer)
-        }
-    }
-
     /// Provide an annotator to inform how to annotate the serialization of the current object.
     pub fn with<T>(value: Option<&dyn Annotate>, f: impl FnOnce(Option<&dyn Annotate>) -> T) -> T {
         ANNOTATE.with(|annotate| {
@@ -77,19 +52,6 @@ impl AnnotatedSerializer {
         })
     }
 
-    /// Convert a generic `Serializer` into `Self`, panic on failure.
-    pub fn specialize<S: serde::Serializer>(
-        serializer: S,
-        f: impl FnOnce(&mut AnnotatedSerializer) -> Result<Document, Error>,
-    ) -> Result<S::Ok, S::Error> {
-        Self::try_specialize(serializer, f, |_| {
-            panic!(
-                "Expected to be called by AnnotatedSerializer, not {:?}",
-                std::any::type_name::<S>(),
-            );
-        })
-    }
-
     fn with_base(&self, b: Base) -> Self {
         let mut x = self.clone();
         x.base = b;

serde_annotate/src/partial.rs

@@ -49,18 +49,3 @@ rust_test(
         "@crate_index//:serde",
     ],
 )
-
-rust_test(
-    name = "test_partial",
-    srcs = ["test_partial.rs"],
-    edition = "2021",
-    proc_macro_deps = [
-        "//serde_annotate_derive",
-    ],
-    deps = [
-        "//serde_annotate",
-        "@crate_index//:anyhow",
-        "@crate_index//:serde",
-        "@crate_index//:serde_json",
-    ],
-)