Vendor dependencies for 0.3.0 release

vendor/erased-serde/src/any.rs

@@ -0,0 +1,107 @@
+use alloc::boxed::Box;
+use core::any::TypeId;
+use core::mem::{self, MaybeUninit};
+use core::ptr;
+
+#[cfg(feature = "unstable-debug")]
+use core::any;
+
+pub struct Any {
+    value: Value,
+    drop: unsafe fn(&mut Value),
+    type_id: TypeId,
+
+    /// For panic messages only. Not used for comparison.
+    #[cfg(feature = "unstable-debug")]
+    type_name: &'static str,
+}
+
+union Value {
+    ptr: *mut (),
+    inline: [MaybeUninit<usize>; 2],
+}
+
+fn is_small<T>() -> bool {
+    mem::size_of::<T>() <= mem::size_of::<Value>()
+        && mem::align_of::<T>() <= mem::align_of::<Value>()
+}
+
+impl Any {
+    // This is unsafe -- caller must not hold on to the Any beyond the lifetime
+    // of T.
+    //
+    // Example of bad code:
+    //
+    //    let s = "bad".to_owned();
+    //    let a = Any::new(&s);
+    //    drop(s);
+    //
+    // Now `a.as_ref()` and `a.take()` return references to a dead String.
+    pub(crate) unsafe fn new<T>(t: T) -> Self {
+        let value: Value;
+        let drop: unsafe fn(&mut Value);
+        let type_id = typeid::of::<T>();
+
+        if is_small::<T>() {
+            let mut inline = [MaybeUninit::uninit(); 2];
+            unsafe { ptr::write(inline.as_mut_ptr().cast::<T>(), t) };
+            value = Value { inline };
+            unsafe fn inline_drop<T>(value: &mut Value) {
+                unsafe { ptr::drop_in_place(value.inline.as_mut_ptr().cast::<T>()) }
+            }
+            drop = inline_drop::<T>;
+        } else {
+            let ptr = Box::into_raw(Box::new(t)).cast::<()>();
+            value = Value { ptr };
+            unsafe fn ptr_drop<T>(value: &mut Value) {
+                mem::drop(unsafe { Box::from_raw(value.ptr.cast::<T>()) });
+            }
+            drop = ptr_drop::<T>;
+        }
+
+        Any {
+            value,
+            drop,
+            type_id,
+            #[cfg(feature = "unstable-debug")]
+            type_name: any::type_name::<T>(),
+        }
+    }
+
+    // This is unsafe -- caller is responsible that T is the correct type.
+    pub(crate) unsafe fn take<T>(mut self) -> T {
+        if self.type_id != typeid::of::<T>() {
+            self.invalid_cast_to::<T>();
+        }
+
+        if is_small::<T>() {
+            let ptr = unsafe { self.value.inline.as_mut_ptr().cast::<T>() };
+            let value = unsafe { ptr::read(ptr) };
+            mem::forget(self);
+            value
+        } else {
+            let ptr = unsafe { self.value.ptr.cast::<T>() };
+            let box_t = unsafe { Box::from_raw(ptr) };
+            mem::forget(self);
+            *box_t
+        }
+    }
+
+    #[cfg(not(feature = "unstable-debug"))]
+    fn invalid_cast_to<T>(&self) -> ! {
+        panic!("invalid cast; enable `unstable-debug` feature to debug");
+    }
+
+    #[cfg(feature = "unstable-debug")]
+    fn invalid_cast_to<T>(&self) -> ! {
+        let from = self.type_name;
+        let to = any::type_name::<T>();
+        panic!("invalid cast: {} to {}", from, to);
+    }
+}
+
+impl Drop for Any {
+    fn drop(&mut self) {
+        unsafe { (self.drop)(&mut self.value) }
+    }
+}

vendor/erased-serde/src/error.rs

@@ -0,0 +1,226 @@
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::fmt::{self, Debug, Display};
+use serde::de::Expected;
+
+/// Error when a `Serializer` or `Deserializer` trait object fails.
+pub struct Error {
+    imp: Box<ErrorImpl>,
+}
+
+/// Result type alias where the error is `erased_serde::Error`.
+pub type Result<T> = core::result::Result<T, Error>;
+
+pub(crate) fn erase_de<E: serde::de::Error>(e: E) -> Error {
+    serde::de::Error::custom(e)
+}
+
+pub(crate) fn unerase_de<E: serde::de::Error>(e: Error) -> E {
+    e.as_serde_de_error()
+}
+
+impl Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let error = self.as_serde_de_error::<serde::de::value::Error>();
+        Display::fmt(&error, formatter)
+    }
+}
+
+impl Debug for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let error = self.as_serde_de_error::<serde::de::value::Error>();
+        Debug::fmt(&error, formatter)
+    }
+}
+
+impl serde::ser::StdError for Error {}
+
+enum ErrorImpl {
+    Custom(String),
+    InvalidType {
+        unexpected: Unexpected,
+        expected: String,
+    },
+    InvalidValue {
+        unexpected: Unexpected,
+        expected: String,
+    },
+    InvalidLength {
+        len: usize,
+        expected: String,
+    },
+    UnknownVariant {
+        variant: String,
+        expected: &'static [&'static str],
+    },
+    UnknownField {
+        field: String,
+        expected: &'static [&'static str],
+    },
+    MissingField {
+        field: &'static str,
+    },
+    DuplicateField {
+        field: &'static str,
+    },
+}
+
+enum Unexpected {
+    Bool(bool),
+    Unsigned(u64),
+    Signed(i64),
+    Float(f64),
+    Char(char),
+    Str(String),
+    Bytes(Vec<u8>),
+    Unit,
+    Option,
+    NewtypeStruct,
+    Seq,
+    Map,
+    Enum,
+    UnitVariant,
+    NewtypeVariant,
+    TupleVariant,
+    StructVariant,
+    Other(String),
+}
+
+impl serde::ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        let imp = Box::new(ErrorImpl::Custom(msg.to_string()));
+        Error { imp }
+    }
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        let imp = Box::new(ErrorImpl::Custom(msg.to_string()));
+        Error { imp }
+    }
+
+    fn invalid_type(unexpected: serde::de::Unexpected, expected: &dyn Expected) -> Self {
+        let imp = Box::new(ErrorImpl::InvalidType {
+            unexpected: Unexpected::from_serde(unexpected),
+            expected: expected.to_string(),
+        });
+        Error { imp }
+    }
+
+    fn invalid_value(unexpected: serde::de::Unexpected, expected: &dyn Expected) -> Self {
+        let imp = Box::new(ErrorImpl::InvalidValue {
+            unexpected: Unexpected::from_serde(unexpected),
+            expected: expected.to_string(),
+        });
+        Error { imp }
+    }
+
+    fn invalid_length(len: usize, expected: &dyn Expected) -> Self {
+        let imp = Box::new(ErrorImpl::InvalidLength {
+            len,
+            expected: expected.to_string(),
+        });
+        Error { imp }
+    }
+
+    fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
+        let imp = Box::new(ErrorImpl::UnknownVariant {
+            variant: variant.to_owned(),
+            expected,
+        });
+        Error { imp }
+    }
+
+    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
+        let imp = Box::new(ErrorImpl::UnknownField {
+            field: field.to_owned(),
+            expected,
+        });
+        Error { imp }
+    }
+
+    fn missing_field(field: &'static str) -> Self {
+        let imp = Box::new(ErrorImpl::MissingField { field });
+        Error { imp }
+    }
+
+    fn duplicate_field(field: &'static str) -> Self {
+        let imp = Box::new(ErrorImpl::DuplicateField { field });
+        Error { imp }
+    }
+}
+
+impl Error {
+    fn as_serde_de_error<E: serde::de::Error>(&self) -> E {
+        match self.imp.as_ref() {
+            ErrorImpl::Custom(msg) => E::custom(msg),
+            ErrorImpl::InvalidType {
+                unexpected,
+                expected,
+            } => E::invalid_type(unexpected.as_serde(), &expected.as_str()),
+            ErrorImpl::InvalidValue {
+                unexpected,
+                expected,
+            } => E::invalid_value(unexpected.as_serde(), &expected.as_str()),
+            ErrorImpl::InvalidLength { len, expected } => {
+                E::invalid_length(*len, &expected.as_str())
+            }
+            ErrorImpl::UnknownVariant { variant, expected } => {
+                E::unknown_variant(variant, expected)
+            }
+            ErrorImpl::UnknownField { field, expected } => E::unknown_field(field, expected),
+            ErrorImpl::MissingField { field } => E::missing_field(field),
+            ErrorImpl::DuplicateField { field } => E::duplicate_field(field),
+        }
+    }
+}
+
+impl Unexpected {
+    fn from_serde(unexpected: serde::de::Unexpected) -> Self {
+        match unexpected {
+            serde::de::Unexpected::Bool(value) => Unexpected::Bool(value),
+            serde::de::Unexpected::Unsigned(value) => Unexpected::Unsigned(value),
+            serde::de::Unexpected::Signed(value) => Unexpected::Signed(value),
+            serde::de::Unexpected::Float(value) => Unexpected::Float(value),
+            serde::de::Unexpected::Char(value) => Unexpected::Char(value),
+            serde::de::Unexpected::Str(value) => Unexpected::Str(value.to_owned()),
+            serde::de::Unexpected::Bytes(value) => Unexpected::Bytes(value.to_owned()),
+            serde::de::Unexpected::Unit => Unexpected::Unit,
+            serde::de::Unexpected::Option => Unexpected::Option,
+            serde::de::Unexpected::NewtypeStruct => Unexpected::NewtypeStruct,
+            serde::de::Unexpected::Seq => Unexpected::Seq,
+            serde::de::Unexpected::Map => Unexpected::Map,
+            serde::de::Unexpected::Enum => Unexpected::Enum,
+            serde::de::Unexpected::UnitVariant => Unexpected::UnitVariant,
+            serde::de::Unexpected::NewtypeVariant => Unexpected::NewtypeVariant,
+            serde::de::Unexpected::TupleVariant => Unexpected::TupleVariant,
+            serde::de::Unexpected::StructVariant => Unexpected::StructVariant,
+            serde::de::Unexpected::Other(msg) => Unexpected::Other(msg.to_owned()),
+        }
+    }
+
+    fn as_serde(&self) -> serde::de::Unexpected {
+        match self {
+            Unexpected::Bool(value) => serde::de::Unexpected::Bool(*value),
+            Unexpected::Unsigned(value) => serde::de::Unexpected::Unsigned(*value),
+            Unexpected::Signed(value) => serde::de::Unexpected::Signed(*value),
+            Unexpected::Float(value) => serde::de::Unexpected::Float(*value),
+            Unexpected::Char(value) => serde::de::Unexpected::Char(*value),
+            Unexpected::Str(value) => serde::de::Unexpected::Str(value),
+            Unexpected::Bytes(value) => serde::de::Unexpected::Bytes(value),
+            Unexpected::Unit => serde::de::Unexpected::Unit,
+            Unexpected::Option => serde::de::Unexpected::Option,
+            Unexpected::NewtypeStruct => serde::de::Unexpected::NewtypeStruct,
+            Unexpected::Seq => serde::de::Unexpected::Seq,
+            Unexpected::Map => serde::de::Unexpected::Map,
+            Unexpected::Enum => serde::de::Unexpected::Enum,
+            Unexpected::UnitVariant => serde::de::Unexpected::UnitVariant,
+            Unexpected::NewtypeVariant => serde::de::Unexpected::NewtypeVariant,
+            Unexpected::TupleVariant => serde::de::Unexpected::TupleVariant,
+            Unexpected::StructVariant => serde::de::Unexpected::StructVariant,
+            Unexpected::Other(msg) => serde::de::Unexpected::Other(msg),
+        }
+    }
+}

vendor/erased-serde/src/features_check/error.rs

@@ -0,0 +1 @@
+"erased-serde requires that either `std` (default) or `alloc` feature is enabled"

vendor/erased-serde/src/features_check/mod.rs

@@ -0,0 +1,13 @@
+//! Shows a user-friendly compiler error on incompatible selected features.
+
+#[allow(unused_macros)]
+macro_rules! hide_from_rustfmt {
+    ($mod:item) => {
+        $mod
+    };
+}
+
+#[cfg(not(feature = "alloc"))]
+hide_from_rustfmt! {
+    mod error;
+}

vendor/erased-serde/src/lib.rs

@@ -0,0 +1,144 @@
+//! [![github]](https://github.com/dtolnay/erased-serde) [![crates-io]](https://crates.io/crates/erased-serde) [![docs-rs]](https://docs.rs/erased-serde)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
+//!
+//! <br>
+//!
+//! This crate provides type-erased versions of Serde's `Serialize`, `Serializer`
+//! and `Deserializer` traits that can be used as [trait objects].
+//!
+//! [trait objects]: https://doc.rust-lang.org/book/trait-objects.html
+//!
+//! The usual Serde `Serialize`, `Serializer` and `Deserializer` traits cannot
+//! be used as trait objects like `&dyn Serialize` or boxed trait objects like
+//! `Box<dyn Serialize>` because of Rust's ["object safety" rules]. In
+//! particular, all three traits contain generic methods which cannot be made
+//! into a trait object.
+//!
+//! ["object safety" rules]: http://huonw.github.io/blog/2015/01/object-safety/
+//!
+//! This library should be considered a low-level building block for interacting
+//! with Serde APIs in an object-safe way. Most use cases will require higher
+//! level functionality such as provided by [`typetag`] which uses this crate
+//! internally.
+//!
+//! [`typetag`]: https://github.com/dtolnay/typetag
+//!
+//! **The traits in this crate work seamlessly with any existing Serde
+//! `Serialize` and `Deserialize` type and any existing Serde `Serializer` and
+//! `Deserializer` format.**
+//!
+//! ## Serialization
+//!
+//! ```rust
+//! use erased_serde::{Serialize, Serializer};
+//! use std::collections::BTreeMap as Map;
+//! use std::io;
+//!
+//! fn main() {
+//!     // Construct some serializers.
+//!     let json = &mut serde_json::Serializer::new(io::stdout());
+//!     let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout()));
+//!
+//!     // The values in this map are boxed trait objects. Ordinarily this would not
+//!     // be possible with serde::Serializer because of object safety, but type
+//!     // erasure makes it possible with erased_serde::Serializer.
+//!     let mut formats: Map<&str, Box<dyn Serializer>> = Map::new();
+//!     formats.insert("json", Box::new(<dyn Serializer>::erase(json)));
+//!     formats.insert("cbor", Box::new(<dyn Serializer>::erase(cbor)));
+//!
+//!     // These are boxed trait objects as well. Same thing here - type erasure
+//!     // makes this possible.
+//!     let mut values: Map<&str, Box<dyn Serialize>> = Map::new();
+//!     values.insert("vec", Box::new(vec!["a", "b"]));
+//!     values.insert("int", Box::new(65536));
+//!
+//!     // Pick a Serializer out of the formats map.
+//!     let format = formats.get_mut("json").unwrap();
+//!
+//!     // Pick a Serialize out of the values map.
+//!     let value = values.get("vec").unwrap();
+//!
+//!     // This line prints `["a","b"]` to stdout.
+//!     value.erased_serialize(format).unwrap();
+//! }
+//! ```
+//!
+//! ## Deserialization
+//!
+//! ```rust
+//! use erased_serde::Deserializer;
+//! use std::collections::BTreeMap as Map;
+//!
+//! fn main() {
+//!     static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#;
+//!     static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66];
+//!
+//!     // Construct some deserializers.
+//!     let json = &mut serde_json::Deserializer::from_slice(JSON);
+//!     let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR);
+//!
+//!     // The values in this map are boxed trait objects, which is not possible
+//!     // with the normal serde::Deserializer because of object safety.
+//!     let mut formats: Map<&str, Box<dyn Deserializer>> = Map::new();
+//!     formats.insert("json", Box::new(<dyn Deserializer>::erase(json)));
+//!     formats.insert("cbor", Box::new(<dyn Deserializer>::erase(cbor)));
+//!
+//!     // Pick a Deserializer out of the formats map.
+//!     let format = formats.get_mut("json").unwrap();
+//!
+//!     let data: Map<String, usize> = erased_serde::deserialize(format).unwrap();
+//!
+//!     println!("{}", data["A"] + data["B"]);
+//! }
+//! ```
+
+#![doc(html_root_url = "https://docs.rs/erased-serde/0.4.8")]
+#![no_std]
+#![deny(unsafe_op_in_unsafe_fn)]
+#![allow(
+    clippy::box_collection,
+    clippy::derive_partial_eq_without_eq,
+    clippy::extra_unused_type_parameters,
+    clippy::items_after_statements,
+    clippy::manual_map, // https://github.com/rust-lang/rust-clippy/issues/7820
+    clippy::missing_errors_doc,
+    clippy::needless_doctest_main,
+    clippy::needless_pass_by_ref_mut,
+    clippy::needless_pass_by_value,
+    clippy::semicolon_if_nothing_returned, // https://github.com/rust-lang/rust-clippy/issues/7324
+    clippy::similar_names,
+    clippy::struct_field_names,
+    clippy::unused_self,
+    clippy::wildcard_imports
+)]
+#![allow(unknown_lints, mismatched_lifetime_syntaxes)]
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+extern crate serde_core as serde;
+
+#[macro_use]
+mod macros;
+
+mod any;
+mod de;
+mod error;
+mod features_check;
+mod map;
+mod sealed;
+mod ser;
+
+pub use crate::de::{deserialize, Deserializer};
+pub use crate::error::{Error, Result};
+pub use crate::ser::{serialize, Serialize, Serializer};
+
+// Not public API.
+#[doc(hidden)]
+#[path = "private.rs"]
+pub mod __private;

vendor/erased-serde/src/macros.rs

@@ -0,0 +1,165 @@
+/// Implement `serde::Serialize` for a trait object that has
+/// `erased_serde::Serialize` as a supertrait.
+///
+/// ```
+/// use erased_serde::serialize_trait_object;
+///
+/// trait Event: erased_serde::Serialize {
+///     /* ... */
+/// }
+///
+/// erased_serde::serialize_trait_object!(Event);
+/// ```
+///
+/// The macro supports traits that have type parameters and/or `where` clauses.
+///
+/// ```
+/// # use erased_serde::serialize_trait_object;
+/// #
+/// trait Difficult<T>: erased_serde::Serialize where T: Copy {
+///     /* ... */
+/// }
+///
+/// serialize_trait_object!(<T> Difficult<T> where T: Copy);
+/// ```
+#[macro_export]
+macro_rules! serialize_trait_object {
+    ($($path:tt)+) => {
+        $crate::__internal_serialize_trait_object!(begin $($path)+);
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __internal_serialize_trait_object {
+    // Invocation started with `<`, parse generics.
+    (begin < $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(generics () () $($rest)*);
+    };
+
+    // Invocation did not start with `<`.
+    (begin $first:tt $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(path () ($first) $($rest)*);
+    };
+
+    // End of generics with trailing comma.
+    (generics ($($generics:tt)*) () , > $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*);
+    };
+
+    // End of generics without trailing comma.
+    (generics ($($generics:tt)*) () > $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*);
+    };
+
+    // Generics open bracket.
+    (generics ($($generics:tt)*) ($($brackets:tt)*) < $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(generics ($($generics)* <) ($($brackets)* <) $($rest)*);
+    };
+
+    // Generics close bracket.
+    (generics ($($generics:tt)*) (< $($brackets:tt)*) > $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(generics ($($generics)* >) ($($brackets)*) $($rest)*);
+    };
+
+    // Token inside of generics.
+    (generics ($($generics:tt)*) ($($brackets:tt)*) $first:tt $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(generics ($($generics)* $first) ($($brackets)*) $($rest)*);
+    };
+
+    // End with `where` clause.
+    (path ($($generics:tt)*) ($($path:tt)*) where $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ($($rest)*));
+    };
+
+    // End without `where` clause.
+    (path ($($generics:tt)*) ($($path:tt)*)) => {
+        $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ());
+    };
+
+    // Token inside of path.
+    (path ($($generics:tt)*) ($($path:tt)*) $first:tt $($rest:tt)*) => {
+        $crate::__internal_serialize_trait_object!(path ($($generics)*) ($($path)* $first) $($rest)*);
+    };
+
+    // Expand into four impls.
+    (sendsync ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*)) => {
+        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)*) ($($bound)*) {
+            fn __check_erased_serialize_supertrait<$($generics)* __T>()
+            where
+                __T: ?$crate::__private::Sized + $($path)*,
+                $($bound)*
+            {
+                $crate::__private::require_erased_serialize_impl::<__T>();
+            }
+        });
+        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send) ($($bound)*));
+        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Sync) ($($bound)*));
+        $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send + $crate::__private::Sync) ($($bound)*));
+    };
+
+    // The impl.
+    (impl ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*) $({$($body:tt)*})*) => {
+        impl<'erased, $($generics)*> $crate::__private::serde::Serialize for dyn $($path)* + 'erased
+        where
+            $($bound)*
+        {
+            fn serialize<S>(&self, serializer: S) -> $crate::__private::Result<S::Ok, S::Error>
+            where
+                S: $crate::__private::serde::Serializer,
+            {
+                $($($body)*)*
+                $crate::serialize(self, serializer)
+            }
+        }
+    };
+}
+
+// TEST ////////////////////////////////////////////////////////////////////////
+
+#[cfg(test)]
+mod tests {
+    use crate::Serialize;
+
+    fn assert_serialize<T: ?Sized + serde::Serialize>() {}
+
+    #[test]
+    fn test_plain() {
+        trait Trait: Serialize {}
+
+        serialize_trait_object!(Trait);
+        assert_serialize::<dyn Trait>();
+        assert_serialize::<dyn Trait + Send>();
+    }
+
+    #[test]
+    fn test_type_parameter() {
+        trait Trait<T>: Serialize {}
+
+        serialize_trait_object!(<T> Trait<T>);
+        assert_serialize::<dyn Trait<u32>>();
+        assert_serialize::<dyn Trait<u32> + Send>();
+    }
+
+    #[test]
+    fn test_generic_bound() {
+        trait Trait<T: PartialEq<T>, U>: Serialize {}
+
+        serialize_trait_object!(<T: PartialEq<T>, U> Trait<T, U>);
+        assert_serialize::<dyn Trait<u32, ()>>();
+        assert_serialize::<dyn Trait<u32, ()> + Send>();
+    }
+
+    #[test]
+    fn test_where_clause() {
+        trait Trait<T>: Serialize
+        where
+            T: Clone,
+        {
+        }
+
+        serialize_trait_object!(<T> Trait<T> where T: Clone);
+        assert_serialize::<dyn Trait<u32>>();
+        assert_serialize::<dyn Trait<u32> + Send>();
+    }
+}

vendor/erased-serde/src/map.rs

@@ -0,0 +1,25 @@
+pub(crate) trait ResultExt<T, E> {
+    unsafe fn unsafe_map<U>(self, op: unsafe fn(T) -> U) -> Result<U, E>;
+}
+
+impl<T, E> ResultExt<T, E> for Result<T, E> {
+    unsafe fn unsafe_map<U>(self, op: unsafe fn(T) -> U) -> Result<U, E> {
+        match self {
+            Ok(t) => Ok(unsafe { op(t) }),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+pub(crate) trait OptionExt<T> {
+    unsafe fn unsafe_map<U>(self, op: unsafe fn(T) -> U) -> Option<U>;
+}
+
+impl<T> OptionExt<T> for Option<T> {
+    unsafe fn unsafe_map<U>(self, op: unsafe fn(T) -> U) -> Option<U> {
+        match self {
+            Some(t) => Some(unsafe { op(t) }),
+            None => None,
+        }
+    }
+}

vendor/erased-serde/src/private.rs

@@ -0,0 +1,20 @@
+//! Not public API. Used as `$crate::__private` by macros.
+
+#[doc(hidden)]
+pub mod serde {
+    #[doc(hidden)]
+    pub use serde::*;
+}
+
+#[doc(hidden)]
+pub use core::marker::{Send, Sized, Sync};
+
+#[doc(hidden)]
+pub type Result<T, E> = core::result::Result<T, E>;
+
+#[doc(hidden)]
+pub fn require_erased_serialize_impl<T>()
+where
+    T: ?Sized + crate::Serialize,
+{
+}

vendor/erased-serde/src/sealed.rs

@@ -0,0 +1,11 @@
+pub mod serialize {
+    pub trait Sealed {}
+}
+
+pub mod serializer {
+    pub trait Sealed {}
+}
+
+pub mod deserializer {
+    pub trait Sealed {}
+}