summaryrefslogtreecommitdiffstats
path: root/third_party/rust/serde/src
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/serde/src')
-rw-r--r--third_party/rust/serde/src/de/impls.rs119
-rw-r--r--third_party/rust/serde/src/de/mod.rs8
-rw-r--r--third_party/rust/serde/src/lib.rs5
-rw-r--r--third_party/rust/serde/src/private/de.rs7
-rw-r--r--third_party/rust/serde/src/private/doc.rs5
-rw-r--r--third_party/rust/serde/src/private/ser.rs132
-rw-r--r--third_party/rust/serde/src/ser/fmt.rs16
-rw-r--r--third_party/rust/serde/src/ser/impls.rs51
-rw-r--r--third_party/rust/serde/src/ser/impossible.rs32
-rw-r--r--third_party/rust/serde/src/ser/mod.rs79
10 files changed, 282 insertions, 172 deletions
diff --git a/third_party/rust/serde/src/de/impls.rs b/third_party/rust/serde/src/de/impls.rs
index 413c997afd..140878aec6 100644
--- a/third_party/rust/serde/src/de/impls.rs
+++ b/third_party/rust/serde/src/de/impls.rs
@@ -104,6 +104,28 @@ macro_rules! impl_deserialize_num {
deserializer.$deserialize(NonZeroVisitor)
}
}
+
+ #[cfg(not(no_core_num_saturating))]
+ impl<'de> Deserialize<'de> for Saturating<$primitive> {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct SaturatingVisitor;
+
+ impl<'de> Visitor<'de> for SaturatingVisitor {
+ type Value = Saturating<$primitive>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("integer with support for saturating semantics")
+ }
+
+ $($($method!(saturating $primitive $val : $visit);)*)*
+ }
+
+ deserializer.$deserialize(SaturatingVisitor)
+ }
+ }
};
($primitive:ident, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => {
@@ -154,6 +176,15 @@ macro_rules! num_self {
}
}
};
+
+ (saturating $primitive:ident $ty:ident : $visit:ident) => {
+ fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Saturating(v))
+ }
+ };
}
macro_rules! num_as_self {
@@ -179,6 +210,15 @@ macro_rules! num_as_self {
}
}
};
+
+ (saturating $primitive:ident $ty:ident : $visit:ident) => {
+ fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Saturating(v as $primitive))
+ }
+ };
}
macro_rules! num_as_copysign_self {
@@ -235,6 +275,21 @@ macro_rules! int_to_int {
Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
}
};
+
+ (saturating $primitive:ident $ty:ident : $visit:ident) => {
+ fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ if (v as i64) < $primitive::MIN as i64 {
+ Ok(Saturating($primitive::MIN))
+ } else if ($primitive::MAX as i64) < v as i64 {
+ Ok(Saturating($primitive::MAX))
+ } else {
+ Ok(Saturating(v as $primitive))
+ }
+ }
+ };
}
macro_rules! int_to_uint {
@@ -265,6 +320,21 @@ macro_rules! int_to_uint {
Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
}
};
+
+ (saturating $primitive:ident $ty:ident : $visit:ident) => {
+ fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ if v < 0 {
+ Ok(Saturating(0))
+ } else if ($primitive::MAX as u64) < v as u64 {
+ Ok(Saturating($primitive::MAX))
+ } else {
+ Ok(Saturating(v as $primitive))
+ }
+ }
+ };
}
macro_rules! uint_to_self {
@@ -295,6 +365,19 @@ macro_rules! uint_to_self {
Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
}
};
+
+ (saturating $primitive:ident $ty:ident : $visit:ident) => {
+ fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ if v as u64 <= $primitive::MAX as u64 {
+ Ok(Saturating(v as $primitive))
+ } else {
+ Ok(Saturating($primitive::MAX))
+ }
+ }
+ };
}
impl_deserialize_num! {
@@ -427,6 +510,21 @@ macro_rules! num_128 {
}
}
};
+
+ (saturating $primitive:ident $ty:ident : $visit:ident) => {
+ fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ if (v as i128) < $primitive::MIN as i128 {
+ Ok(Saturating($primitive::MIN))
+ } else if ($primitive::MAX as u128) < v as u128 {
+ Ok(Saturating($primitive::MAX))
+ } else {
+ Ok(Saturating(v as $primitive))
+ }
+ }
+ };
}
impl_deserialize_num! {
@@ -852,7 +950,10 @@ struct PhantomDataVisitor<T: ?Sized> {
marker: PhantomData<T>,
}
-impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
+impl<'de, T> Visitor<'de> for PhantomDataVisitor<T>
+where
+ T: ?Sized,
+{
type Value = PhantomData<T>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -868,7 +969,10 @@ impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
}
}
-impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
+impl<'de, T> Deserialize<'de> for PhantomData<T>
+where
+ T: ?Sized,
+{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
@@ -1877,9 +1981,9 @@ forwarded_impl! {
#[cfg(any(feature = "std", feature = "alloc"))]
#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
+impl<'de, 'a, T> Deserialize<'de> for Cow<'a, T>
where
- T: ToOwned,
+ T: ?Sized + ToOwned,
T::Owned: Deserialize<'de>,
{
#[inline]
@@ -1902,7 +2006,7 @@ where
doc_cfg,
doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
)]
-impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
+impl<'de, T> Deserialize<'de> for RcWeak<T>
where
T: Deserialize<'de>,
{
@@ -1924,7 +2028,7 @@ where
doc_cfg,
doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
)]
-impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
+impl<'de, T> Deserialize<'de> for ArcWeak<T>
where
T: Deserialize<'de>,
{
@@ -1945,8 +2049,9 @@ macro_rules! box_forwarded_impl {
$t:ident
) => {
$(#[$attr])*
- impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
+ impl<'de, T> Deserialize<'de> for $t<T>
where
+ T: ?Sized,
Box<T>: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
diff --git a/third_party/rust/serde/src/de/mod.rs b/third_party/rust/serde/src/de/mod.rs
index 1924fe3d88..4c5a5f9b78 100644
--- a/third_party/rust/serde/src/de/mod.rs
+++ b/third_party/rust/serde/src/de/mod.rs
@@ -1735,9 +1735,9 @@ pub trait SeqAccess<'de> {
}
}
-impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
+impl<'de, 'a, A> SeqAccess<'de> for &'a mut A
where
- A: SeqAccess<'de>,
+ A: ?Sized + SeqAccess<'de>,
{
type Error = A::Error;
@@ -1888,9 +1888,9 @@ pub trait MapAccess<'de> {
}
}
-impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A
+impl<'de, 'a, A> MapAccess<'de> for &'a mut A
where
- A: MapAccess<'de>,
+ A: ?Sized + MapAccess<'de>,
{
type Error = A::Error;
diff --git a/third_party/rust/serde/src/lib.rs b/third_party/rust/serde/src/lib.rs
index 5cf44c1c18..fefbf8fda2 100644
--- a/third_party/rust/serde/src/lib.rs
+++ b/third_party/rust/serde/src/lib.rs
@@ -95,7 +95,7 @@
////////////////////////////////////////////////////////////////////////////////
// Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.197")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.198")]
// Support using Serde without the standard library!
#![cfg_attr(not(feature = "std"), no_std)]
// Show which crate feature enables conditionally compiled APIs in documentation.
@@ -274,6 +274,9 @@ mod lib {
pub use std::sync::atomic::{AtomicI64, AtomicU64};
#[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))]
pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
+
+ #[cfg(not(no_core_num_saturating))]
+ pub use self::core::num::Saturating;
}
// None of this crate's error handling needs the `From::from` error conversion
diff --git a/third_party/rust/serde/src/private/de.rs b/third_party/rust/serde/src/private/de.rs
index 883e6909c1..c402d2c66a 100644
--- a/third_party/rust/serde/src/private/de.rs
+++ b/third_party/rust/serde/src/private/de.rs
@@ -313,6 +313,8 @@ mod content {
}
}
+ /// Used to capture data in [`Content`] from other deserializers.
+ /// Cannot capture externally tagged enums, `i128` and `u128`.
struct ContentVisitor<'de> {
value: PhantomData<Content<'de>>,
}
@@ -528,6 +530,8 @@ mod content {
Content(Content<'de>),
}
+ /// Serves as a seed for deserializing a key of internally tagged enum.
+ /// Cannot capture externally tagged enums, `i128` and `u128`.
struct TagOrContentVisitor<'de> {
name: &'static str,
value: PhantomData<TagOrContent<'de>>,
@@ -814,6 +818,9 @@ mod content {
/// Used by generated code to deserialize an internally tagged enum.
///
+ /// Captures map or sequence from the original deserializer and searches
+ /// a tag in it (in case of sequence, tag is the first element of sequence).
+ ///
/// Not public API.
pub struct TaggedContentVisitor<T> {
tag_name: &'static str,
diff --git a/third_party/rust/serde/src/private/doc.rs b/third_party/rust/serde/src/private/doc.rs
index 1b18fe6b41..1f17c8db53 100644
--- a/third_party/rust/serde/src/private/doc.rs
+++ b/third_party/rust/serde/src/private/doc.rs
@@ -56,7 +56,10 @@ macro_rules! __serialize_unimplemented {
#[macro_export]
macro_rules! __serialize_unimplemented_method {
($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
- fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
+ fn $func $(<$t>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error>
+ where
+ $($t: ?Sized + $crate::Serialize,)*
+ {
unimplemented!()
}
};
diff --git a/third_party/rust/serde/src/private/ser.rs b/third_party/rust/serde/src/private/ser.rs
index 50bcb251e3..40cc6cbdb7 100644
--- a/third_party/rust/serde/src/private/ser.rs
+++ b/third_party/rust/serde/src/private/ser.rs
@@ -174,9 +174,9 @@ where
Err(self.bad_type(Unsupported::Optional))
}
- fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
+ fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Err(self.bad_type(Unsupported::Optional))
}
@@ -205,18 +205,18 @@ where
map.end()
}
- fn serialize_newtype_struct<T: ?Sized>(
+ fn serialize_newtype_struct<T>(
self,
_: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
value.serialize(self)
}
- fn serialize_newtype_variant<T: ?Sized>(
+ fn serialize_newtype_variant<T>(
self,
_: &'static str,
_: u32,
@@ -224,7 +224,7 @@ where
inner_value: &T,
) -> Result<Self::Ok, Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let mut map = tri!(self.delegate.serialize_map(Some(2)));
tri!(map.serialize_entry(self.tag, self.variant_name));
@@ -327,9 +327,9 @@ where
}
#[cfg(not(any(feature = "std", feature = "alloc")))]
- fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
+ fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
where
- T: Display,
+ T: ?Sized + Display,
{
Err(self.bad_type(Unsupported::String))
}
@@ -364,9 +364,9 @@ mod content {
type Ok = M::Ok;
type Error = M::Error;
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), M::Error>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), M::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push(value);
@@ -404,13 +404,9 @@ mod content {
type Ok = M::Ok;
type Error = M::Error;
- fn serialize_field<T: ?Sized>(
- &mut self,
- key: &'static str,
- value: &T,
- ) -> Result<(), M::Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), M::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value));
@@ -635,9 +631,9 @@ mod content {
Ok(Content::None)
}
- fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E>
+ fn serialize_some<T>(self, value: &T) -> Result<Content, E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Ok(Content::Some(Box::new(tri!(value.serialize(self)))))
}
@@ -659,13 +655,9 @@ mod content {
Ok(Content::UnitVariant(name, variant_index, variant))
}
- fn serialize_newtype_struct<T: ?Sized>(
- self,
- name: &'static str,
- value: &T,
- ) -> Result<Content, E>
+ fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Content, E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Ok(Content::NewtypeStruct(
name,
@@ -673,7 +665,7 @@ mod content {
))
}
- fn serialize_newtype_variant<T: ?Sized>(
+ fn serialize_newtype_variant<T>(
self,
name: &'static str,
variant_index: u32,
@@ -681,7 +673,7 @@ mod content {
value: &T,
) -> Result<Content, E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Ok(Content::NewtypeVariant(
name,
@@ -782,9 +774,9 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value);
@@ -808,9 +800,9 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value);
@@ -835,9 +827,9 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value);
@@ -864,9 +856,9 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value);
@@ -896,18 +888,18 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E>
+ fn serialize_key<T>(&mut self, key: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let key = tri!(key.serialize(ContentSerializer::<E>::new()));
self.key = Some(key);
Ok(())
}
- fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ fn serialize_value<T>(&mut self, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let key = self
.key
@@ -922,10 +914,10 @@ mod content {
Ok(Content::Map(self.entries))
}
- fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
+ fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), E>
where
- K: Serialize,
- V: Serialize,
+ K: ?Sized + Serialize,
+ V: ?Sized + Serialize,
{
let key = tri!(key.serialize(ContentSerializer::<E>::new()));
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
@@ -947,9 +939,9 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value));
@@ -976,9 +968,9 @@ mod content {
type Ok = Content;
type Error = E;
- fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), E>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value));
@@ -1088,9 +1080,9 @@ where
Ok(())
}
- fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+ fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
value.serialize(self)
}
@@ -1112,18 +1104,18 @@ where
Err(Self::bad_type(Unsupported::Enum))
}
- fn serialize_newtype_struct<T: ?Sized>(
+ fn serialize_newtype_struct<T>(
self,
_: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
value.serialize(self)
}
- fn serialize_newtype_variant<T: ?Sized>(
+ fn serialize_newtype_variant<T>(
self,
_: &'static str,
_: u32,
@@ -1131,7 +1123,7 @@ where
value: &T,
) -> Result<Self::Ok, Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
tri!(self.0.serialize_key(variant));
self.0.serialize_value(value)
@@ -1202,28 +1194,24 @@ where
type Ok = ();
type Error = M::Error;
- fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+ fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
self.0.serialize_key(key)
}
- fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
self.0.serialize_value(value)
}
- fn serialize_entry<K: ?Sized, V: ?Sized>(
- &mut self,
- key: &K,
- value: &V,
- ) -> Result<(), Self::Error>
+ fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
where
- K: Serialize,
- V: Serialize,
+ K: ?Sized + Serialize,
+ V: ?Sized + Serialize,
{
self.0.serialize_entry(key, value)
}
@@ -1244,13 +1232,9 @@ where
type Ok = ();
type Error = M::Error;
- fn serialize_field<T: ?Sized>(
- &mut self,
- key: &'static str,
- value: &T,
- ) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
self.0.serialize_entry(key, value)
}
@@ -1289,9 +1273,9 @@ where
type Ok = ();
type Error = M::Error;
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push(value);
@@ -1335,13 +1319,9 @@ where
type Ok = ();
type Error = M::Error;
- fn serialize_field<T: ?Sized>(
- &mut self,
- key: &'static str,
- value: &T,
- ) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value));
diff --git a/third_party/rust/serde/src/ser/fmt.rs b/third_party/rust/serde/src/ser/fmt.rs
index 0650ab6f12..04684aded0 100644
--- a/third_party/rust/serde/src/ser/fmt.rs
+++ b/third_party/rust/serde/src/ser/fmt.rs
@@ -74,9 +74,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Display::fmt(variant, self)
}
- fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
+ fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> fmt::Result
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Serialize::serialize(value, self)
}
@@ -89,9 +89,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Err(fmt::Error)
}
- fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
+ fn serialize_some<T>(self, _value: &T) -> fmt::Result
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Err(fmt::Error)
}
@@ -100,7 +100,7 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Err(fmt::Error)
}
- fn serialize_newtype_variant<T: ?Sized>(
+ fn serialize_newtype_variant<T>(
self,
_name: &'static str,
_variant_index: u32,
@@ -108,7 +108,7 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
_value: &T,
) -> fmt::Result
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
Err(fmt::Error)
}
@@ -161,9 +161,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Err(fmt::Error)
}
- fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
+ fn collect_str<T>(self, value: &T) -> fmt::Result
where
- T: Display,
+ T: ?Sized + Display,
{
Display::fmt(value, self)
}
diff --git a/third_party/rust/serde/src/ser/impls.rs b/third_party/rust/serde/src/ser/impls.rs
index 8c70634af0..ffc4c70f90 100644
--- a/third_party/rust/serde/src/ser/impls.rs
+++ b/third_party/rust/serde/src/ser/impls.rs
@@ -114,7 +114,10 @@ where
////////////////////////////////////////////////////////////////////////////////
-impl<T: ?Sized> Serialize for PhantomData<T> {
+impl<T> Serialize for PhantomData<T>
+where
+ T: ?Sized,
+{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -504,17 +507,17 @@ macro_rules! deref_impl {
}
deref_impl! {
- <'a, T: ?Sized> Serialize for &'a T where T: Serialize
+ <'a, T> Serialize for &'a T where T: ?Sized + Serialize
}
deref_impl! {
- <'a, T: ?Sized> Serialize for &'a mut T where T: Serialize
+ <'a, T> Serialize for &'a mut T where T: ?Sized + Serialize
}
deref_impl! {
#[cfg(any(feature = "std", feature = "alloc"))]
#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
- <T: ?Sized> Serialize for Box<T> where T: Serialize
+ <T> Serialize for Box<T> where T: ?Sized + Serialize
}
deref_impl! {
@@ -528,7 +531,7 @@ deref_impl! {
/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
#[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
- <T: ?Sized> Serialize for Rc<T> where T: Serialize
+ <T> Serialize for Rc<T> where T: ?Sized + Serialize
}
deref_impl! {
@@ -542,13 +545,13 @@ deref_impl! {
/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
#[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
- <T: ?Sized> Serialize for Arc<T> where T: Serialize
+ <T> Serialize for Arc<T> where T: ?Sized + Serialize
}
deref_impl! {
#[cfg(any(feature = "std", feature = "alloc"))]
#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
- <'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned
+ <'a, T> Serialize for Cow<'a, T> where T: ?Sized + Serialize + ToOwned
}
////////////////////////////////////////////////////////////////////////////////
@@ -561,9 +564,9 @@ deref_impl! {
doc_cfg,
doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
)]
-impl<T: ?Sized> Serialize for RcWeak<T>
+impl<T> Serialize for RcWeak<T>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -581,9 +584,9 @@ where
doc_cfg,
doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
)]
-impl<T: ?Sized> Serialize for ArcWeak<T>
+impl<T> Serialize for ArcWeak<T>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -641,9 +644,9 @@ where
}
}
-impl<T: ?Sized> Serialize for RefCell<T>
+impl<T> Serialize for RefCell<T>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -658,9 +661,9 @@ where
#[cfg(feature = "std")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<T: ?Sized> Serialize for Mutex<T>
+impl<T> Serialize for Mutex<T>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -675,9 +678,9 @@ where
#[cfg(feature = "std")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<T: ?Sized> Serialize for RwLock<T>
+impl<T> Serialize for RwLock<T>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -1023,6 +1026,20 @@ where
}
}
+#[cfg(not(no_core_num_saturating))]
+impl<T> Serialize for Saturating<T>
+where
+ T: Serialize,
+{
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ self.0.serialize(serializer)
+ }
+}
+
impl<T> Serialize for Reverse<T>
where
T: Serialize,
diff --git a/third_party/rust/serde/src/ser/impossible.rs b/third_party/rust/serde/src/ser/impossible.rs
index 479be94071..6432d5775a 100644
--- a/third_party/rust/serde/src/ser/impossible.rs
+++ b/third_party/rust/serde/src/ser/impossible.rs
@@ -72,9 +72,9 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = value;
match self.void {}
@@ -92,9 +92,9 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = value;
match self.void {}
@@ -112,9 +112,9 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = value;
match self.void {}
@@ -132,9 +132,9 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = value;
match self.void {}
@@ -152,17 +152,17 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
+ fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = key;
match self.void {}
}
- fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = value;
match self.void {}
@@ -180,9 +180,9 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = key;
let _ = value;
@@ -201,9 +201,9 @@ where
type Ok = Ok;
type Error = Error;
- fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where
- T: Serialize,
+ T: ?Sized + Serialize,
{
let _ = key;
let _ = value;
diff --git a/third_party/rust/serde/src/ser/mod.rs b/third_party/rust/serde/src/ser/mod.rs
index 75c45140e2..74b5e07691 100644
--- a/third_party/rust/serde/src/ser/mod.rs
+++ b/third_party/rust/serde/src/ser/mod.rs
@@ -796,9 +796,9 @@ pub trait Serializer: Sized {
/// ```
///
/// [`Some(T)`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
- fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+ fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Serialize a `()` value.
///
@@ -891,13 +891,13 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
- fn serialize_newtype_struct<T: ?Sized>(
+ fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
///
@@ -925,7 +925,7 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
- fn serialize_newtype_variant<T: ?Sized>(
+ fn serialize_newtype_variant<T>(
self,
name: &'static str,
variant_index: u32,
@@ -933,7 +933,7 @@ pub trait Serializer: Sized {
value: &T,
) -> Result<Self::Ok, Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Begin to serialize a variably sized sequence. This call must be
/// followed by zero or more calls to `serialize_element`, then a call to
@@ -1170,7 +1170,8 @@ pub trait Serializer: Sized {
/// then a call to `end`.
///
/// The `name` is the name of the struct and the `len` is the number of
- /// data fields that will be serialized.
+ /// data fields that will be serialized. `len` does not include fields
+ /// which are skipped with [`SerializeStruct::skip_field`].
///
/// ```edition2021
/// use serde::ser::{Serialize, SerializeStruct, Serializer};
@@ -1207,6 +1208,8 @@ pub trait Serializer: Sized {
/// The `name` is the name of the enum, the `variant_index` is the index of
/// this variant within the enum, the `variant` is the name of the variant,
/// and the `len` is the number of data fields that will be serialized.
+ /// `len` does not include fields which are skipped with
+ /// [`SerializeStructVariant::skip_field`].
///
/// ```edition2021
/// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
@@ -1346,9 +1349,9 @@ pub trait Serializer: Sized {
/// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
/// [`serialize_str`]: #tymethod.serialize_str
#[cfg(any(feature = "std", feature = "alloc"))]
- fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+ fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
- T: Display,
+ T: ?Sized + Display,
{
self.serialize_str(&value.to_string())
}
@@ -1379,9 +1382,9 @@ pub trait Serializer: Sized {
/// }
/// ```
#[cfg(not(any(feature = "std", feature = "alloc")))]
- fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+ fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
- T: Display;
+ T: ?Sized + Display;
/// Determine whether `Serialize` implementations should serialize in
/// human-readable form.
@@ -1493,9 +1496,9 @@ pub trait SerializeSeq {
type Error: Error;
/// Serialize a sequence element.
- fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Finish serializing a sequence.
fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1593,9 +1596,9 @@ pub trait SerializeTuple {
type Error: Error;
/// Serialize a tuple element.
- fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Finish serializing a tuple.
fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1638,9 +1641,9 @@ pub trait SerializeTupleStruct {
type Error: Error;
/// Serialize a tuple struct field.
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Finish serializing a tuple struct.
fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1696,9 +1699,9 @@ pub trait SerializeTupleVariant {
type Error: Error;
/// Serialize a tuple variant field.
- fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Finish serializing a tuple variant.
fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1767,9 +1770,9 @@ pub trait SerializeMap {
/// `serialize_entry` instead as it may be implemented more efficiently in
/// some formats compared to a pair of calls to `serialize_key` and
/// `serialize_value`.
- fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+ fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Serialize a map value.
///
@@ -1777,9 +1780,9 @@ pub trait SerializeMap {
///
/// Calling `serialize_value` before `serialize_key` is incorrect and is
/// allowed to panic or produce bogus results.
- fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Serialize a map entry consisting of a key and a value.
///
@@ -1798,14 +1801,10 @@ pub trait SerializeMap {
/// [`Serialize`]: ../trait.Serialize.html
/// [`serialize_key`]: #tymethod.serialize_key
/// [`serialize_value`]: #tymethod.serialize_value
- fn serialize_entry<K: ?Sized, V: ?Sized>(
- &mut self,
- key: &K,
- value: &V,
- ) -> Result<(), Self::Error>
+ fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
where
- K: Serialize,
- V: Serialize,
+ K: ?Sized + Serialize,
+ V: ?Sized + Serialize,
{
tri!(self.serialize_key(key));
self.serialize_value(value)
@@ -1856,15 +1855,13 @@ pub trait SerializeStruct {
type Error: Error;
/// Serialize a struct field.
- fn serialize_field<T: ?Sized>(
- &mut self,
- key: &'static str,
- value: &T,
- ) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Indicate that a struct field has been skipped.
+ ///
+ /// The default implementation does nothing.
#[inline]
fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
let _ = key;
@@ -1922,15 +1919,13 @@ pub trait SerializeStructVariant {
type Error: Error;
/// Serialize a struct variant field.
- fn serialize_field<T: ?Sized>(
- &mut self,
- key: &'static str,
- value: &T,
- ) -> Result<(), Self::Error>
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
- T: Serialize;
+ T: ?Sized + Serialize;
/// Indicate that a struct variant field has been skipped.
+ ///
+ /// The default implementation does nothing.
#[inline]
fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
let _ = key;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-08 03:29:33 +0000