Release 1.0.199

Merge pull request #2732 from aatifsyed/master
fix: ambiguous associated item in forward_to_deserialize_any!
2026-04-23 03:38:00 +00:00 · 2024-04-26 21:22:11 -07:00 · 2024-04-26 21:21:40 -07:00 · 2024-04-26 13:04:00 +02:00 · 2024-04-19 20:57:45 -07:00 · 2024-04-16 14:18:01 -07:00
36 changed files with 798 additions and 390 deletions
@@ -168,5 +168,6 @@ jobs:
    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
      - uses: dtolnay/install@cargo-outdated
      - run: cargo outdated --workspace --exit-code 1
@@ -8,3 +8,8 @@ members = [

 [patch.crates-io]
 serde = { path = "serde" }
+
+[workspace.dependencies]
+proc-macro2 = { version = "1.0.74", default-features = false }
+quote = { version = "1.0.35", default-features = false }
+syn = { version = "2.0.46", default-features = false }
@@ -1,11 +1,11 @@
-# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.31+]][Rust 1.31] [![serde_derive: rustc 1.56+]][Rust 1.56]
+# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde msrv]][Rust 1.31] [![serde_derive msrv]][Rust 1.56]

 [Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master
 [actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
 [Latest Version]: https://img.shields.io/crates/v/serde.svg
 [crates.io]: https://crates.io/crates/serde
-[serde: rustc 1.31+]: https://img.shields.io/badge/serde-rustc_1.31+-lightgray.svg
-[serde_derive: rustc 1.56+]: https://img.shields.io/badge/serde_derive-rustc_1.56+-lightgray.svg
+[serde msrv]: https://img.shields.io/crates/msrv/serde.svg?label=serde%20msrv&color=lightgray
+[serde_derive msrv]: https://img.shields.io/crates/msrv/serde_derive.svg?label=serde_derive%20msrv&color=lightgray
 [Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
 [Rust 1.56]: https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.191"
+version = "1.0.199"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
@@ -37,7 +37,7 @@ rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]
 # is compatible with exactly one serde release because the generated code
 # involves nonpublic APIs which are not bound by semver.
 [target.'cfg(any())'.dependencies]
-serde_derive = { version = "=1.0.191", path = "../serde_derive" }
+serde_derive = { version = "=1.0.199", path = "../serde_derive" }


 ### FEATURES #################################################################
@@ -64,6 +64,12 @@ fn main() {
    if minor < 64 {
        println!("cargo:rustc-cfg=no_core_cstr");
    }
+
+    // Support for core::num::Saturating and std::num::Saturating stabilized in Rust 1.74
+    // https://blog.rust-lang.org/2023/11/16/Rust-1.74.0.html#stabilized-apis
+    if minor < 74 {
+        println!("cargo:rustc-cfg=no_core_num_saturating");
+    }
 }

 fn rustc_minor_version() -> Option<u32> {
@@ -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>
@@ -2526,144 +2631,6 @@ mod range_from {

    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};

-    pub const FIELDS: &[&str] = &["end"];
-
-    // If this were outside of the serde crate, it would just use:
-    //
-    //    #[derive(Deserialize)]
-    //    #[serde(field_identifier, rename_all = "lowercase")]
-    enum Field {
-        End,
-    }
-
-    impl<'de> Deserialize<'de> for Field {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct FieldVisitor;
-
-            impl<'de> Visitor<'de> for FieldVisitor {
-                type Value = Field;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`end`")
-                }
-
-                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        "end" => Ok(Field::End),
-                        _ => Err(Error::unknown_field(value, FIELDS)),
-                    }
-                }
-
-                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        b"end" => Ok(Field::End),
-                        _ => {
-                            let value = crate::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&*value, FIELDS))
-                        }
-                    }
-                }
-            }
-
-            deserializer.deserialize_identifier(FieldVisitor)
-        }
-    }
-
-    pub struct RangeFromVisitor<Idx> {
-        pub expecting: &'static str,
-        pub phantom: PhantomData<Idx>,
-    }
-
-    impl<'de, Idx> Visitor<'de> for RangeFromVisitor<Idx>
-    where
-        Idx: Deserialize<'de>,
-    {
-        type Value = Idx;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str(self.expecting)
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let end: Idx = match tri!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(0, &self));
-                }
-            };
-            Ok(end)
-        }
-
-        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>,
-        {
-            let mut end: Option<Idx> = None;
-            while let Some(key) = tri!(map.next_key()) {
-                match key {
-                    Field::End => {
-                        if end.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("end"));
-                        }
-                        end = Some(tri!(map.next_value()));
-                    }
-                }
-            }
-            let end = match end {
-                Some(end) => end,
-                None => return Err(<A::Error as Error>::missing_field("end")),
-            };
-            Ok(end)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Similar to:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct RangeTo<Idx> {
-//         start: Idx,
-//     }
-impl<'de, Idx> Deserialize<'de> for RangeTo<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let end = tri!(deserializer.deserialize_struct(
-            "RangeTo",
-            range_to::FIELDS,
-            range_to::RangeToVisitor {
-                expecting: "struct RangeTo",
-                phantom: PhantomData,
-            },
-        ));
-        Ok(..end)
-    }
-}
-
-mod range_to {
-    use crate::lib::*;
-
-    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
-
    pub const FIELDS: &[&str] = &["start"];

    // If this were outside of the serde crate, it would just use:
@@ -2716,12 +2683,12 @@ mod range_to {
        }
    }

-    pub struct RangeToVisitor<Idx> {
+    pub struct RangeFromVisitor<Idx> {
        pub expecting: &'static str,
        pub phantom: PhantomData<Idx>,
    }

-    impl<'de, Idx> Visitor<'de> for RangeToVisitor<Idx>
+    impl<'de, Idx> Visitor<'de> for RangeFromVisitor<Idx>
    where
        Idx: Deserialize<'de>,
    {
@@ -2770,6 +2737,144 @@ mod range_to {

 ////////////////////////////////////////////////////////////////////////////////

+// Similar to:
+//
+//     #[derive(Deserialize)]
+//     #[serde(deny_unknown_fields)]
+//     struct RangeTo<Idx> {
+//         end: Idx,
+//     }
+impl<'de, Idx> Deserialize<'de> for RangeTo<Idx>
+where
+    Idx: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let end = tri!(deserializer.deserialize_struct(
+            "RangeTo",
+            range_to::FIELDS,
+            range_to::RangeToVisitor {
+                expecting: "struct RangeTo",
+                phantom: PhantomData,
+            },
+        ));
+        Ok(..end)
+    }
+}
+
+mod range_to {
+    use crate::lib::*;
+
+    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+
+    pub const FIELDS: &[&str] = &["end"];
+
+    // If this were outside of the serde crate, it would just use:
+    //
+    //    #[derive(Deserialize)]
+    //    #[serde(field_identifier, rename_all = "lowercase")]
+    enum Field {
+        End,
+    }
+
+    impl<'de> Deserialize<'de> for Field {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct FieldVisitor;
+
+            impl<'de> Visitor<'de> for FieldVisitor {
+                type Value = Field;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("`end`")
+                }
+
+                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        "end" => Ok(Field::End),
+                        _ => Err(Error::unknown_field(value, FIELDS)),
+                    }
+                }
+
+                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        b"end" => Ok(Field::End),
+                        _ => {
+                            let value = crate::__private::from_utf8_lossy(value);
+                            Err(Error::unknown_field(&*value, FIELDS))
+                        }
+                    }
+                }
+            }
+
+            deserializer.deserialize_identifier(FieldVisitor)
+        }
+    }
+
+    pub struct RangeToVisitor<Idx> {
+        pub expecting: &'static str,
+        pub phantom: PhantomData<Idx>,
+    }
+
+    impl<'de, Idx> Visitor<'de> for RangeToVisitor<Idx>
+    where
+        Idx: Deserialize<'de>,
+    {
+        type Value = Idx;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str(self.expecting)
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let end: Idx = match tri!(seq.next_element()) {
+                Some(value) => value,
+                None => {
+                    return Err(Error::invalid_length(0, &self));
+                }
+            };
+            Ok(end)
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let mut end: Option<Idx> = None;
+            while let Some(key) = tri!(map.next_key()) {
+                match key {
+                    Field::End => {
+                        if end.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("end"));
+                        }
+                        end = Some(tri!(map.next_value()));
+                    }
+                }
+            }
+            let end = match end {
+                Some(end) => end,
+                None => return Err(<A::Error as Error>::missing_field("end")),
+            };
+            Ok(end)
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 impl<'de, T> Deserialize<'de> for Bound<T>
 where
    T: Deserialize<'de>,
@@ -64,8 +64,8 @@
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -402,20 +402,20 @@ impl<'a> fmt::Display for Unexpected<'a> {
            Bool(b) => write!(formatter, "boolean `{}`", b),
            Unsigned(i) => write!(formatter, "integer `{}`", i),
            Signed(i) => write!(formatter, "integer `{}`", i),
-            Float(f) => write!(formatter, "floating point `{}`", f),
+            Float(f) => write!(formatter, "floating point `{}`", WithDecimalPoint(f)),
            Char(c) => write!(formatter, "character `{}`", c),
            Str(s) => write!(formatter, "string {:?}", s),
-            Bytes(_) => write!(formatter, "byte array"),
-            Unit => write!(formatter, "unit value"),
-            Option => write!(formatter, "Option value"),
-            NewtypeStruct => write!(formatter, "newtype struct"),
-            Seq => write!(formatter, "sequence"),
-            Map => write!(formatter, "map"),
-            Enum => write!(formatter, "enum"),
-            UnitVariant => write!(formatter, "unit variant"),
-            NewtypeVariant => write!(formatter, "newtype variant"),
-            TupleVariant => write!(formatter, "tuple variant"),
-            StructVariant => write!(formatter, "struct variant"),
+            Bytes(_) => formatter.write_str("byte array"),
+            Unit => formatter.write_str("unit value"),
+            Option => formatter.write_str("Option value"),
+            NewtypeStruct => formatter.write_str("newtype struct"),
+            Seq => formatter.write_str("sequence"),
+            Map => formatter.write_str("map"),
+            Enum => formatter.write_str("enum"),
+            UnitVariant => formatter.write_str("unit variant"),
+            NewtypeVariant => formatter.write_str("newtype variant"),
+            TupleVariant => formatter.write_str("tuple variant"),
+            StructVariant => formatter.write_str("struct variant"),
            Other(other) => formatter.write_str(other),
        }
    }
@@ -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;

@@ -2278,10 +2278,10 @@ impl Display for OneOf {
            1 => write!(formatter, "`{}`", self.names[0]),
            2 => write!(formatter, "`{}` or `{}`", self.names[0], self.names[1]),
            _ => {
-                tri!(write!(formatter, "one of "));
+                tri!(formatter.write_str("one of "));
                for (i, alt) in self.names.iter().enumerate() {
                    if i > 0 {
-                        tri!(write!(formatter, ", "));
+                        tri!(formatter.write_str(", "));
                    }
                    tri!(write!(formatter, "`{}`", alt));
                }
@@ -2290,3 +2290,36 @@ impl Display for OneOf {
        }
    }
 }
+
+struct WithDecimalPoint(f64);
+
+impl Display for WithDecimalPoint {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        struct LookForDecimalPoint<'f, 'a> {
+            formatter: &'f mut fmt::Formatter<'a>,
+            has_decimal_point: bool,
+        }
+
+        impl<'f, 'a> fmt::Write for LookForDecimalPoint<'f, 'a> {
+            fn write_str(&mut self, fragment: &str) -> fmt::Result {
+                self.has_decimal_point |= fragment.contains('.');
+                self.formatter.write_str(fragment)
+            }
+
+            fn write_char(&mut self, ch: char) -> fmt::Result {
+                self.has_decimal_point |= ch == '.';
+                self.formatter.write_char(ch)
+            }
+        }
+
+        let mut writer = LookForDecimalPoint {
+            formatter,
+            has_decimal_point: false,
+        };
+        tri!(write!(writer, "{}", self.0));
+        if !writer.has_decimal_point {
+            tri!(formatter.write_str(".0"));
+        }
+        Ok(())
+    }
+}
@@ -983,7 +983,7 @@ struct ExpectedInSeq(usize);
 impl Expected for ExpectedInSeq {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if self.0 == 1 {
-            write!(formatter, "1 element in sequence")
+            formatter.write_str("1 element in sequence")
        } else {
            write!(formatter, "{} elements in sequence", self.0)
        }
@@ -1411,7 +1411,7 @@ struct ExpectedInMap(usize);
 impl Expected for ExpectedInMap {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        if self.0 == 1 {
-            write!(formatter, "1 element in map")
+            formatter.write_str("1 element in map")
        } else {
            write!(formatter, "{} elements in map", self.0)
        }
@@ -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.191")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.199")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Show which crate feature enables conditionally compiled APIs in documentation.
@@ -118,11 +118,11 @@
    // integer and float ser/de requires these sorts of casts
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
    clippy::cast_sign_loss,
    // things are often more readable this way
    clippy::cast_lossless,
    clippy::module_name_repetitions,
-    clippy::option_if_let_else,
    clippy::single_match_else,
    clippy::type_complexity,
    clippy::use_self,
@@ -131,6 +131,7 @@
    clippy::derive_partial_eq_without_eq,
    clippy::enum_glob_use,
    clippy::explicit_auto_deref,
+    clippy::incompatible_msrv,
    clippy::let_underscore_untyped,
    clippy::map_err_ignore,
    clippy::new_without_default,
@@ -179,16 +180,16 @@ mod lib {
    pub use self::core::{cmp, mem, slice};

    pub use self::core::cell::{Cell, RefCell};
-    pub use self::core::clone::{self, Clone};
+    pub use self::core::clone;
    pub use self::core::cmp::Reverse;
-    pub use self::core::convert::{self, From, Into};
-    pub use self::core::default::{self, Default};
-    pub use self::core::fmt::{self, Debug, Display};
+    pub use self::core::convert;
+    pub use self::core::default;
+    pub use self::core::fmt::{self, Debug, Display, Write as FmtWrite};
    pub use self::core::marker::{self, PhantomData};
    pub use self::core::num::Wrapping;
    pub use self::core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
-    pub use self::core::option::{self, Option};
-    pub use self::core::result::{self, Result};
+    pub use self::core::option;
+    pub use self::core::result;
    pub use self::core::time::Duration;

    #[cfg(all(feature = "alloc", not(feature = "std")))]
@@ -274,6 +275,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
@@ -123,7 +123,7 @@ macro_rules! forward_to_deserialize_any {
 macro_rules! forward_to_deserialize_any_method {
    ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
        #[inline]
-        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
+        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, <Self as $crate::de::Deserializer<$l>>::Error>
        where
            $v: $crate::de::Visitor<$l>,
        {
@@ -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,
@@ -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!()
        }
    };
@@ -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));
@@ -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)
    }
@@ -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,
@@ -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;
@@ -61,8 +61,8 @@
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -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;
@@ -1,10 +1,11 @@
 [package]
 name = "serde_derive"
-version = "1.0.191"
+version = "1.0.199"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 categories = ["no-std", "no-std::no-alloc"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
 documentation = "https://serde.rs/derive.html"
+edition = "2015"
 homepage = "https://serde.rs"
 keywords = ["serde", "serialization", "no_std", "derive"]
 license = "MIT OR Apache-2.0"
@@ -21,9 +22,9 @@ name = "serde_derive"
 proc-macro = true

 [dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = "2.0.28"
+proc-macro2 = { workspace = true, features = ["proc-macro"] }
+quote = { workspace = true, features = ["proc-macro"] }
+syn = { workspace = true, features = ["clone-impls", "derive", "parsing", "printing", "proc-macro"] }

 [dev-dependencies]
 serde = { version = "1", path = "../serde" }
@@ -144,6 +144,7 @@ pub fn with_bound(

        fn visit_type(&mut self, ty: &'ast syn::Type) {
            match ty {
+                #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                syn::Type::Array(ty) => self.visit_type(&ty.elem),
                syn::Type::BareFn(ty) => {
                    for arg in &ty.inputs {
@@ -181,7 +182,6 @@ pub fn with_bound(

                syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}

-                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                _ => {}
            }
        }
@@ -196,16 +196,13 @@ pub fn with_bound(
                syn::PathArguments::AngleBracketed(arguments) => {
                    for arg in &arguments.args {
                        match arg {
+                            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                            syn::GenericArgument::Type(arg) => self.visit_type(arg),
                            syn::GenericArgument::AssocType(arg) => self.visit_type(&arg.ty),
                            syn::GenericArgument::Lifetime(_)
                            | syn::GenericArgument::Const(_)
                            | syn::GenericArgument::AssocConst(_)
                            | syn::GenericArgument::Constraint(_) => {}
-                            #[cfg_attr(
-                                all(test, exhaustive),
-                                deny(non_exhaustive_omitted_patterns)
-                            )]
                            _ => {}
                        }
                    }
@@ -228,9 +225,9 @@ pub fn with_bound(

        fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
            match bound {
+                #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
                syn::TypeParamBound::Lifetime(_) | syn::TypeParamBound::Verbatim(_) => {}
-                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                _ => {}
            }
        }
@@ -1794,6 +1794,7 @@ fn borrowable_lifetimes(

 fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
    match ty {
+        #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
        syn::Type::Slice(ty) => {
            collect_lifetimes(&ty.elem, out);
        }
@@ -1829,7 +1830,10 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
                            syn::GenericArgument::AssocType(binding) => {
                                collect_lifetimes(&binding.ty, out);
                            }
-                            _ => {}
+                            syn::GenericArgument::Const(_)
+                            | syn::GenericArgument::AssocConst(_)
+                            | syn::GenericArgument::Constraint(_)
+                            | _ => {}
                        }
                    }
                }
@@ -1851,7 +1855,6 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
        | syn::Type::Infer(_)
        | syn::Type::Verbatim(_) => {}

-        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
        _ => {}
    }
 }
@@ -318,6 +318,9 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
    for variant in variants {
        match variant.style {
            Style::Struct => {
+                if variant.attrs.untagged() {
+                    continue;
+                }
                for field in &variant.fields {
                    let check_ser =
                        !(field.attrs.skip_serializing() || variant.attrs.skip_serializing());
@@ -107,6 +107,7 @@ impl ReplaceReceiver<'_> {

    fn visit_type_mut_impl(&mut self, ty: &mut Type) {
        match ty {
+            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
            Type::Array(ty) => {
                self.visit_type_mut(&mut ty.elem);
                self.visit_expr_mut(&mut ty.len);
@@ -147,7 +148,6 @@ impl ReplaceReceiver<'_> {

            Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}

-            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
            _ => {}
        }
    }
@@ -178,13 +178,13 @@ impl ReplaceReceiver<'_> {
            PathArguments::AngleBracketed(arguments) => {
                for arg in &mut arguments.args {
                    match arg {
+                        #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                        GenericArgument::Type(arg) => self.visit_type_mut(arg),
                        GenericArgument::AssocType(arg) => self.visit_type_mut(&mut arg.ty),
                        GenericArgument::Lifetime(_)
                        | GenericArgument::Const(_)
                        | GenericArgument::AssocConst(_)
                        | GenericArgument::Constraint(_) => {}
-                        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                        _ => {}
                    }
                }
@@ -207,9 +207,9 @@ impl ReplaceReceiver<'_> {

    fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
        match bound {
+            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
            TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path),
            TypeParamBound::Lifetime(_) | TypeParamBound::Verbatim(_) => {}
-            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
            _ => {}
        }
    }
@@ -228,6 +228,7 @@ impl ReplaceReceiver<'_> {
        if let Some(where_clause) = &mut generics.where_clause {
            for predicate in &mut where_clause.predicates {
                match predicate {
+                    #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                    WherePredicate::Type(predicate) => {
                        self.visit_type_mut(&mut predicate.bounded_ty);
                        for bound in &mut predicate.bounds {
@@ -235,7 +236,6 @@ impl ReplaceReceiver<'_> {
                        }
                    }
                    WherePredicate::Lifetime(_) => {}
-                    #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                    _ => {}
                }
            }
@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.191")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.199")]
 // Ignored clippy lints
 #![allow(
    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
@@ -50,7 +50,6 @@
    clippy::match_wildcard_for_single_variants,
    clippy::module_name_repetitions,
    clippy::must_use_candidate,
-    clippy::option_if_let_else,
    clippy::similar_names,
    clippy::single_match_else,
    clippy::struct_excessive_bools,
@@ -64,14 +64,14 @@ pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
 fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
    match &cont.data {
        Data::Enum(variants) => pretend_fields_used_enum(cont, variants),
-        Data::Struct(Style::Struct, fields) => {
+        Data::Struct(Style::Struct | Style::Tuple | Style::Newtype, fields) => {
            if is_packed {
                pretend_fields_used_struct_packed(cont, fields)
            } else {
                pretend_fields_used_struct(cont, fields)
            }
        }
-        Data::Struct(_, _) => quote!(),
+        Data::Struct(Style::Unit, _) => quote!(),
    }
 }

@@ -115,13 +115,13 @@ fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStre
    let patterns = variants
        .iter()
        .filter_map(|variant| match variant.style {
-            Style::Struct => {
+            Style::Struct | Style::Tuple | Style::Newtype => {
                let variant_ident = &variant.ident;
                let members = variant.fields.iter().map(|field| &field.member);
                let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
                Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
            }
-            _ => None,
+            Style::Unit => None,
        })
        .collect::<Vec<_>>();

@@ -289,7 +289,7 @@ fn serialize_tuple_struct(
 }

 fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    assert!(fields.len() as u64 <= u64::from(u32::max_value()));
+    assert!(fields.len() as u64 <= u64::from(u32::MAX));

    if cattrs.has_flatten() {
        serialize_struct_as_map(params, fields, cattrs)
@@ -397,7 +397,7 @@ fn serialize_struct_as_map(
 }

 fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
-    assert!(variants.len() as u64 <= u64::from(u32::max_value()));
+    assert!(variants.len() as u64 <= u64::from(u32::MAX));

    let self_var = &params.self_var;

@@ -4,6 +4,7 @@ version = "0.29.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 description = "AST representation used by Serde derive macros. Unstable."
 documentation = "https://docs.rs/serde_derive_internals"
+edition = "2015"
 exclude = ["build.rs"]
 homepage = "https://serde.rs"
 keywords = ["serde", "serialization"]
@@ -15,9 +16,9 @@ rust-version = "1.56"
 path = "lib.rs"

 [dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = { version = "2.0.28", default-features = false, features = ["clone-impls", "derive", "parsing", "printing"] }
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn = { workspace = true, features = ["clone-impls", "derive", "parsing", "printing"] }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
@@ -7,7 +7,9 @@ pub struct Nested;
 pub enum ExternallyTagged {
    Flatten {
        #[serde(flatten)]
+        #[allow(dead_code)]
        nested: Nested,
+        #[allow(dead_code)]
        string: &'static str,
    },
 }
@@ -17,7 +19,9 @@ pub enum ExternallyTagged {
 pub enum InternallyTagged {
    Flatten {
        #[serde(flatten)]
+        #[allow(dead_code)]
        nested: Nested,
+        #[allow(dead_code)]
        string: &'static str,
    },
 }
@@ -27,7 +31,9 @@ pub enum InternallyTagged {
 pub enum AdjacentlyTagged {
    Flatten {
        #[serde(flatten)]
+        #[allow(dead_code)]
        nested: Nested,
+        #[allow(dead_code)]
        string: &'static str,
    },
 }
@@ -37,7 +43,9 @@ pub enum AdjacentlyTagged {
 pub enum UntaggedWorkaround {
    Flatten {
        #[serde(flatten)]
+        #[allow(dead_code)]
        nested: Nested,
+        #[allow(dead_code)]
        string: &'static str,
    },
 }
@@ -23,7 +23,7 @@ use std::iter;
 use std::net;
 use std::num::{
    NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
-    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
+    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Saturating, Wrapping,
 };
 use std::ops::Bound;
 use std::path::{Path, PathBuf};
@@ -1898,6 +1898,46 @@ fn test_range_inclusive() {
    );
 }

+#[test]
+fn test_range_from() {
+    test(
+        1u32..,
+        &[
+            Token::Struct {
+                name: "RangeFrom",
+                len: 1,
+            },
+            Token::Str("start"),
+            Token::U32(1),
+            Token::StructEnd,
+        ],
+    );
+    test(
+        1u32..,
+        &[Token::Seq { len: Some(1) }, Token::U32(1), Token::SeqEnd],
+    );
+}
+
+#[test]
+fn test_range_to() {
+    test(
+        ..2u32,
+        &[
+            Token::Struct {
+                name: "RangeTo",
+                len: 1,
+            },
+            Token::Str("end"),
+            Token::U32(2),
+            Token::StructEnd,
+        ],
+    );
+    test(
+        ..2u32,
+        &[Token::Seq { len: Some(1) }, Token::U32(2), Token::SeqEnd],
+    );
+}
+
 #[test]
 fn test_bound() {
    test(
@@ -2025,6 +2065,43 @@ fn test_wrapping() {
    test(Wrapping(1usize), &[Token::U64(1)]);
 }

+#[test]
+fn test_saturating() {
+    test(Saturating(1usize), &[Token::U32(1)]);
+    test(Saturating(1usize), &[Token::U64(1)]);
+    test(Saturating(0u8), &[Token::I8(0)]);
+    test(Saturating(0u16), &[Token::I16(0)]);
+
+    // saturate input values at the minimum or maximum value
+    test(Saturating(u8::MAX), &[Token::U16(u16::MAX)]);
+    test(Saturating(u8::MAX), &[Token::U16(u8::MAX as u16 + 1)]);
+    test(Saturating(u16::MAX), &[Token::U32(u32::MAX)]);
+    test(Saturating(u32::MAX), &[Token::U64(u64::MAX)]);
+    test(Saturating(u8::MIN), &[Token::I8(i8::MIN)]);
+    test(Saturating(u16::MIN), &[Token::I16(i16::MIN)]);
+    test(Saturating(u32::MIN), &[Token::I32(i32::MIN)]);
+    test(Saturating(i8::MIN), &[Token::I16(i16::MIN)]);
+    test(Saturating(i16::MIN), &[Token::I32(i32::MIN)]);
+    test(Saturating(i32::MIN), &[Token::I64(i64::MIN)]);
+
+    test(Saturating(u8::MIN), &[Token::I8(-1)]);
+    test(Saturating(u16::MIN), &[Token::I16(-1)]);
+
+    #[cfg(target_pointer_width = "64")]
+    {
+        test(Saturating(usize::MIN), &[Token::U64(u64::MIN)]);
+        test(Saturating(usize::MAX), &[Token::U64(u64::MAX)]);
+        test(Saturating(isize::MIN), &[Token::I64(i64::MIN)]);
+        test(Saturating(isize::MAX), &[Token::I64(i64::MAX)]);
+        test(Saturating(0usize), &[Token::I64(i64::MIN)]);
+
+        test(
+            Saturating(9_223_372_036_854_775_807usize),
+            &[Token::I64(i64::MAX)],
+        );
+    }
+}
+
 #[test]
 fn test_rc_dst() {
    test(Rc::<str>::from("s"), &[Token::Str("s")]);
@@ -1434,7 +1434,7 @@ fn test_number_from_string() {
 fn test_integer_from_float() {
    assert_de_tokens_error::<isize>(
        &[Token::F32(0.0)],
-        "invalid type: floating point `0`, expected isize",
+        "invalid type: floating point `0.0`, expected isize",
    );
 }

@@ -1459,7 +1459,7 @@ fn test_duration_overflow_seq() {
    assert_de_tokens_error::<Duration>(
        &[
            Token::Seq { len: Some(2) },
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
            Token::U32(1_000_000_000),
            Token::SeqEnd,
        ],
@@ -1476,7 +1476,7 @@ fn test_duration_overflow_struct() {
                len: 2,
            },
            Token::Str("secs"),
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
            Token::Str("nanos"),
            Token::U32(1_000_000_000),
            Token::StructEnd,
@@ -1490,7 +1490,7 @@ fn test_systemtime_overflow_seq() {
    assert_de_tokens_error::<SystemTime>(
        &[
            Token::Seq { len: Some(2) },
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
            Token::U32(1_000_000_000),
            Token::SeqEnd,
        ],
@@ -1507,7 +1507,7 @@ fn test_systemtime_overflow_struct() {
                len: 2,
            },
            Token::Str("secs_since_epoch"),
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
            Token::Str("nanos_since_epoch"),
            Token::U32(1_000_000_000),
            Token::StructEnd,
@@ -1522,7 +1522,7 @@ fn test_systemtime_overflow() {
    assert_de_tokens_error::<SystemTime>(
        &[
            Token::Seq { len: Some(2) },
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
            Token::U32(0),
            Token::SeqEnd,
        ],
@@ -686,9 +686,17 @@ fn test_gen() {

    #[derive(Deserialize)]
    #[serde(untagged)]
-    enum UntaggedWithBorrow<'a> {
-        Single(#[serde(borrow)] RelObject<'a>),
-        Many(#[serde(borrow)] Vec<RelObject<'a>>),
+    pub enum UntaggedWithBorrow<'a> {
+        Single(
+            #[serde(borrow)]
+            #[allow(dead_code)]
+            RelObject<'a>,
+        ),
+        Many(
+            #[serde(borrow)]
+            #[allow(dead_code)]
+            Vec<RelObject<'a>>,
+        ),
    }

    #[derive(Deserialize)]
@@ -730,6 +738,7 @@ fn test_gen() {

    #[derive(Serialize)]
    #[repr(packed)]
+    #[allow(dead_code)]
    struct Packed {
        x: u8,
        y: u16,
@@ -761,6 +770,7 @@ fn test_gen() {
    }

    #[derive(Serialize)]
+    #[allow(dead_code)]
    struct Struct {
        #[serde(serialize_with = "vec_first_element")]
        vec: Vec<Self>,
@@ -814,6 +814,100 @@ fn test_internally_tagged_enum() {
    );
 }

+#[test]
+fn test_internally_tagged_enum_with_untagged_variant() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "kind")]
+    enum InternallyTagged {
+        Tagged {
+            a: u8,
+        },
+        #[serde(untagged)]
+        Untagged {
+            kind: String,
+            b: u8,
+        },
+    }
+
+    assert_de_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("kind"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Tagged".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_internally_tagged_bytes() {
    #[derive(Debug, PartialEq, Deserialize)]
@@ -987,6 +1081,15 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
        Log { level: Level },
    }

+    assert_de_tokens(
+        &Level::Info,
+        &[
+            Token::Enum { name: "Level" },
+            Token::BorrowedStr("Info"),
+            Token::Unit,
+        ],
+    );
+
    assert_de_tokens(
        &Message::Log { level: Level::Info },
        &[
@@ -997,7 +1100,9 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
            Token::Str("action"),
            Token::Str("Log"),
            Token::Str("level"),
+            Token::Enum { name: "Level" },
            Token::BorrowedStr("Info"),
+            Token::Unit,
            Token::StructEnd,
        ],
    );
@@ -1009,7 +1114,9 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
            Token::Str("action"),
            Token::Str("Log"),
            Token::Str("level"),
+            Token::Enum { name: "Level" },
            Token::BorrowedStr("Info"),
+            Token::Unit,
            Token::MapEnd,
        ],
    );
@@ -1019,7 +1126,9 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
        &[
            Token::Seq { len: Some(2) },
            Token::Str("Log"),
+            Token::Enum { name: "Level" },
            Token::BorrowedStr("Info"),
+            Token::Unit,
            Token::SeqEnd,
        ],
    );
@@ -2125,24 +2234,28 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
 fn test_packed_struct_can_derive_serialize() {
    #[derive(Copy, Clone, Serialize)]
    #[repr(packed, C)]
+    #[allow(dead_code)]
    struct PackedC {
        t: f32,
    }

    #[derive(Copy, Clone, Serialize)]
    #[repr(C, packed)]
+    #[allow(dead_code)]
    struct CPacked {
        t: f32,
    }

    #[derive(Copy, Clone, Serialize)]
    #[repr(C, packed(2))]
+    #[allow(dead_code)]
    struct CPacked2 {
        t: f32,
    }

    #[derive(Copy, Clone, Serialize)]
    #[repr(packed(2), C)]
+    #[allow(dead_code)]
    struct Packed2C {
        t: f32,
    }
@@ -8,7 +8,7 @@ use std::cell::RefCell;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::CString;
 use std::net;
-use std::num::Wrapping;
+use std::num::{Saturating, Wrapping};
 use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak as RcWeak};
@@ -500,6 +500,38 @@ fn test_range_inclusive() {
    );
 }

+#[test]
+fn test_range_from() {
+    assert_ser_tokens(
+        &(1u32..),
+        &[
+            Token::Struct {
+                name: "RangeFrom",
+                len: 1,
+            },
+            Token::Str("start"),
+            Token::U32(1),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_range_to() {
+    assert_ser_tokens(
+        &(..2u32),
+        &[
+            Token::Struct {
+                name: "RangeTo",
+                len: 1,
+            },
+            Token::Str("end"),
+            Token::U32(2),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_bound() {
    assert_ser_tokens(
@@ -592,6 +624,11 @@ fn test_wrapping() {
    assert_ser_tokens(&Wrapping(1usize), &[Token::U64(1)]);
 }

+#[test]
+fn test_saturating() {
+    assert_ser_tokens(&Saturating(1usize), &[Token::U64(1)]);
+}
+
 #[test]
 fn test_rc_dst() {
    assert_ser_tokens(&Rc::<str>::from("s"), &[Token::Str("s")]);
@@ -27,19 +27,21 @@ mod fake_serde {
    {
    }

+    #[allow(dead_code)]
    pub trait Serialize {
        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
    }

+    #[allow(dead_code)]
    pub trait Deserialize<'a>: Sized {
        fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>;
    }
 }

-trait AssertNotSerdeSerialize {}
+pub trait AssertNotSerdeSerialize {}

 impl<T: serde::Serialize> AssertNotSerdeSerialize for T {}

-trait AssertNotSerdeDeserialize<'a> {}
+pub trait AssertNotSerdeDeserialize<'a> {}

 impl<'a, T: serde::Deserialize<'a>> AssertNotSerdeDeserialize<'a> for T {}
@@ -63,7 +63,7 @@ fn test_map_access_to_enum() {
                type Value = Potential;

                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    write!(formatter, "a map")
+                    formatter.write_str("a map")
                }

                fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
@@ -3,6 +3,11 @@ error[E0609]: no field `b` on type `&remote::S`
   |
 12 |     b: u8,
   |     ^ unknown field
+   |
+help: a field with a similar name exists
+   |
+12 |     a: u8,
+   |     ~

 error[E0560]: struct `remote::S` has no field named `b`
  --> tests/ui/remote/unknown_field.rs:12:5
@@ -12,7 +12,3 @@ note: tuple struct defined here
 4 |     pub struct S(pub u16);
  |                ^
  = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: you can convert a `u8` to a `u16`
-  |
-7 | #[derive(Deserialize.into())]
-  |                     +++++++