Release 1.0.202

Release serde_derive_internals 0.29.1
Merge pull request #2743 from dtolnay/renameallrules
2026-04-23 07:08:02 +00:00 · 2024-05-15 00:42:49 -07:00 · 2024-05-15 00:35:14 -07:00 · 2024-05-15 00:34:38 -07:00 · 2024-05-15 00:30:55 -07:00 · 2024-05-14 23:02:28 -07:00
43 changed files with 1439 additions and 788 deletions
@@ -18,7 +18,7 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd test_suite && cargo test --features unstable

@@ -27,7 +27,7 @@ jobs:
    runs-on: windows-latest
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd test_suite && cargo test --features unstable -- --skip ui --exact

@@ -40,7 +40,7 @@ jobs:
        rust: [stable, beta]
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{matrix.rust}}
@@ -56,7 +56,7 @@ jobs:
        os: [ubuntu, windows]
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd serde && cargo build
      - run: cd serde && cargo build --no-default-features
@@ -80,7 +80,7 @@ jobs:
        rust: [1.31.0, 1.34.0]
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{matrix.rust}}
@@ -93,7 +93,7 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@1.56.0
      - run: cd serde && cargo check --no-default-features
      - run: cd serde && cargo check
@@ -104,7 +104,7 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@1.36.0
      - run: cd serde && cargo build --no-default-features --features alloc

@@ -113,18 +113,32 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@nightly
      - run: cargo generate-lockfile -Z minimal-versions
      - run: cargo check --locked --workspace

+  doc:
+    name: Documentation
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    env:
+      RUSTDOCFLAGS: -Dwarnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/install@cargo-docs-rs
+      - run: cargo docs-rs -p serde
+      - run: cargo docs-rs -p serde_derive
+      - run: cargo docs-rs -p serde_derive_internals
+
  clippy:
    name: Clippy
    runs-on: ubuntu-latest
    if: github.event_name != 'pull_request'
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@clippy
      - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
      - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
@@ -137,7 +151,7 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@miri
      - run: cargo miri setup
      - run: cd serde && cargo miri test --features derive,rc,unstable
@@ -153,6 +167,7 @@ jobs:
    if: github.event_name != 'pull_request'
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v3
+      - 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.186" # remember to update html_root_url and serde_derive dependency
+version = "1.0.202"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
@@ -27,9 +27,9 @@ doc-scrape-examples = false
 features = ["derive", "rc"]

 [package.metadata.docs.rs]
-features = ["derive"]
+features = ["derive", "rc", "unstable"]
 targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = ["--generate-link-to-definition"]
+rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]

 # This cfg cannot be enabled, but it still forces Cargo to keep serde_derive's
 # version in lockstep with serde's, even if someone depends on the two crates
@@ -37,7 +37,7 @@ rustdoc-args = ["--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.186", path = "../serde_derive" }
+serde_derive = { version = "=1.0.202", path = "../serde_derive" }


 ### FEATURES #################################################################
@@ -13,6 +13,21 @@ fn main() {
        None => return,
    };

+    if minor >= 77 {
+        println!("cargo:rustc-check-cfg=cfg(doc_cfg)");
+        println!("cargo:rustc-check-cfg=cfg(no_core_cstr)");
+        println!("cargo:rustc-check-cfg=cfg(no_core_num_saturating)");
+        println!("cargo:rustc-check-cfg=cfg(no_core_try_from)");
+        println!("cargo:rustc-check-cfg=cfg(no_float_copysign)");
+        println!("cargo:rustc-check-cfg=cfg(no_num_nonzero_signed)");
+        println!("cargo:rustc-check-cfg=cfg(no_relaxed_trait_bounds)");
+        println!("cargo:rustc-check-cfg=cfg(no_serde_derive)");
+        println!("cargo:rustc-check-cfg=cfg(no_std_atomic)");
+        println!("cargo:rustc-check-cfg=cfg(no_std_atomic64)");
+        println!("cargo:rustc-check-cfg=cfg(no_systemtime_checked_add)");
+        println!("cargo:rustc-check-cfg=cfg(no_target_has_atomic)");
+    }
+
    let target = env::var("TARGET").unwrap();
    let emscripten = target == "asmjs-unknown-emscripten" || target == "wasm32-unknown-emscripten";

@@ -27,11 +42,10 @@ fn main() {
        println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
    }

-    // Disabled on Emscripten targets before Rust 1.40 since
-    // Emscripten did not support 128-bit integers until Rust 1.40
-    // (https://github.com/rust-lang/rust/pull/65251)
-    if emscripten && minor < 40 {
-        println!("cargo:rustc-cfg=no_integer128");
+    // f32::copysign and f64::copysign stabilized in Rust 1.35.
+    // https://blog.rust-lang.org/2019/05/23/Rust-1.35.0.html#copy-the-sign-of-a-floating-point-number-onto-another
+    if minor < 35 {
+        println!("cargo:rustc-cfg=no_float_copysign");
    }

    // Current minimum supported version of serde_derive crate is Rust 1.56.
@@ -65,6 +79,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> {
@@ -129,12 +129,10 @@ impl<'de> Visitor<'de> for IgnoredAny {
        Ok(IgnoredAny)
    }

-    serde_if_integer128! {
-        #[inline]
-        fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
-            let _ = x;
-            Ok(IgnoredAny)
-        }
+    #[inline]
+    fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
+        let _ = x;
+        Ok(IgnoredAny)
    }

    #[inline]
@@ -143,12 +141,10 @@ impl<'de> Visitor<'de> for IgnoredAny {
        Ok(IgnoredAny)
    }

-    serde_if_integer128! {
-        #[inline]
-        fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
-            let _ = x;
-            Ok(IgnoredAny)
-        }
+    #[inline]
+    fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
+        let _ = x;
+        Ok(IgnoredAny)
    }

    #[inline]
@@ -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\>
@@ -118,7 +118,6 @@ use crate::lib::*;

 pub mod value;

-#[cfg(not(no_integer128))]
 mod format;
 mod ignored_any;
 mod impls;
@@ -403,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),
        }
    }
@@ -949,18 +948,15 @@ pub trait Deserializer<'de>: Sized {
    where
        V: Visitor<'de>;

-    serde_if_integer128! {
-        /// Hint that the `Deserialize` type is expecting an `i128` value.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>
-        {
-            let _ = visitor;
-            Err(Error::custom("i128 is not supported"))
-        }
+    /// Hint that the `Deserialize` type is expecting an `i128` value.
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let _ = visitor;
+        Err(Error::custom("i128 is not supported"))
    }

    /// Hint that the `Deserialize` type is expecting a `u8` value.
@@ -983,18 +979,15 @@ pub trait Deserializer<'de>: Sized {
    where
        V: Visitor<'de>;

-    serde_if_integer128! {
-        /// Hint that the `Deserialize` type is expecting an `u128` value.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>
-        {
-            let _ = visitor;
-            Err(Error::custom("u128 is not supported"))
-        }
+    /// Hint that the `Deserialize` type is expecting an `u128` value.
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let _ = visitor;
+        Err(Error::custom("u128 is not supported"))
    }

    /// Hint that the `Deserialize` type is expecting a `f32` value.
@@ -1366,20 +1359,20 @@ pub trait Visitor<'de>: Sized {
        Err(Error::invalid_type(Unexpected::Signed(v), &self))
    }

-    serde_if_integer128! {
-        /// The input contains a `i128`.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default implementation fails with a type error.
-        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let mut buf = [0u8; 58];
-            let mut writer = format::Buf::new(&mut buf);
-            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
-            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
-        }
+    /// The input contains a `i128`.
+    ///
+    /// The default implementation fails with a type error.
+    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        let mut buf = [0u8; 58];
+        let mut writer = format::Buf::new(&mut buf);
+        fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
+        Err(Error::invalid_type(
+            Unexpected::Other(writer.as_str()),
+            &self,
+        ))
    }

    /// The input contains a `u8`.
@@ -1428,20 +1421,20 @@ pub trait Visitor<'de>: Sized {
        Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
    }

-    serde_if_integer128! {
-        /// The input contains a `u128`.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default implementation fails with a type error.
-        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let mut buf = [0u8; 57];
-            let mut writer = format::Buf::new(&mut buf);
-            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
-            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
-        }
+    /// The input contains a `u128`.
+    ///
+    /// The default implementation fails with a type error.
+    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        let mut buf = [0u8; 57];
+        let mut writer = format::Buf::new(&mut buf);
+        fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
+        Err(Error::invalid_type(
+            Unexpected::Other(writer.as_str()),
+            &self,
+        ))
    }

    /// The input contains an `f32`.
@@ -1532,6 +1525,7 @@ pub trait Visitor<'de>: Sized {
    /// `String`.
    #[inline]
    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: Error,
@@ -1590,6 +1584,7 @@ pub trait Visitor<'de>: Sized {
    /// The default implementation forwards to `visit_bytes` and then drops the
    /// `Vec<u8>`.
    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
    where
        E: Error,
@@ -1740,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;

@@ -1893,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;

@@ -2283,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));
                }
@@ -2295,3 +2290,40 @@ 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)
+            }
+        }
+
+        if self.0.is_finite() {
+            let mut writer = LookForDecimalPoint {
+                formatter,
+                has_decimal_point: false,
+            };
+            tri!(write!(writer, "{}", self.0));
+            if !writer.has_decimal_point {
+                tri!(formatter.write_str(".0"));
+            }
+        } else {
+            tri!(write!(formatter, "{}", self.0));
+        }
+        Ok(())
+    }
+}
@@ -112,6 +112,7 @@ impl Debug for Error {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl error::Error for Error {
    fn description(&self) -> &str {
        &self.err
@@ -184,12 +185,14 @@ impl<E> Debug for UnitDeserializer<E> {

 /// A deserializer that cannot be instantiated.
 #[cfg(feature = "unstable")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
 pub struct NeverDeserializer<E> {
    never: !,
    marker: PhantomData<E>,
 }

 #[cfg(feature = "unstable")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
 impl<'de, E> IntoDeserializer<'de, E> for !
 where
    E: de::Error,
@@ -292,20 +295,17 @@ primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
 primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
 primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
 primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
+primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
 primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
 primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
 primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
 primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
+primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
 primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
 primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);

-serde_if_integer128! {
-    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
-    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
-}
-
 /// A deserializer holding a `u32`.
 pub struct U32Deserializer<E> {
    value: u32,
@@ -565,6 +565,7 @@ impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {

 /// A deserializer holding a `String`.
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 pub struct StringDeserializer<E> {
    value: String,
    marker: PhantomData<E>,
@@ -581,6 +582,7 @@ impl<E> Clone for StringDeserializer<E> {
 }

 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, E> IntoDeserializer<'de, E> for String
 where
    E: de::Error,
@@ -668,6 +670,7 @@ impl<E> Debug for StringDeserializer<E> {

 /// A deserializer holding a `Cow<str>`.
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 pub struct CowStrDeserializer<'a, E> {
    value: Cow<'a, str>,
    marker: PhantomData<E>,
@@ -684,6 +687,7 @@ impl<'a, E> Clone for CowStrDeserializer<'a, E> {
 }

 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
 where
    E: de::Error,
@@ -979,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)
        }
@@ -1002,6 +1006,7 @@ where
 ////////////////////////////////////////////////////////////////////////////////

 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
 where
    T: IntoDeserializer<'de, E>,
@@ -1015,6 +1020,7 @@ where
 }

 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
 where
    T: IntoDeserializer<'de, E> + Eq + Ord,
@@ -1028,6 +1034,7 @@ where
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
 where
    T: IntoDeserializer<'de, E> + Eq + Hash,
@@ -1404,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)
        }
@@ -1414,6 +1421,7 @@ impl Expected for ExpectedInMap {
 ////////////////////////////////////////////////////////////////////////////////

 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
 where
    K: IntoDeserializer<'de, E> + Eq + Ord,
@@ -1428,6 +1436,7 @@ where
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
 where
    K: IntoDeserializer<'de, E> + Eq + Hash,
@@ -1,82 +1,9 @@
-/// Conditional compilation depending on whether Serde is built with support for
-/// 128-bit integers.
-///
-/// Data formats that wish to support Rust compiler versions older than 1.26
-/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
-/// of their Serializer and Deserializer behind this macro.
-///
-/// Data formats that require a minimum Rust compiler version of at least 1.26,
-/// or do not target platforms that lack 128-bit integers, do not need to
-/// bother with this macro and may assume support for 128-bit integers.
-///
-/// ```edition2021
-/// # use serde::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// use serde::{serde_if_integer128, Serializer};
-///
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
-///         /* ... */
-/// #         unimplemented!()
-///     }
-///
-///     /* ... */
-///
-///     serde_if_integer128! {
-///         fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///
-///         fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///     }
-/// #
-/// #     serde::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant seq
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// When Serde is built with support for 128-bit integers, this macro expands
-/// transparently into just the input tokens.
-///
-/// ```edition2021
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {
-///         $($tt)*
-///     };
-/// }
-/// ```
-///
-/// When built without support for 128-bit integers, this macro expands to
-/// nothing.
-///
-/// ```edition2021
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {};
-/// }
-/// ```
-#[cfg(not(no_integer128))]
+// No longer used. Old versions of serde used this macro for supporting targets
+// that did not yet have 128-bit integer support.
 #[macro_export]
+#[doc(hidden)]
 macro_rules! serde_if_integer128 {
    ($($tt:tt)*) => {
        $($tt)*
    };
 }
-
-#[cfg(no_integer128)]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! serde_if_integer128 {
-    ($($tt:tt)*) => {};
-}
@@ -63,6 +63,7 @@
 //!   and from DynamoDB.
 //! - [Hjson], a syntax extension to JSON designed around human reading and
 //!   editing. *(deserialization only)*
+//! - [CSV], Comma-separated values is a tabular text file format.
 //!
 //! [JSON]: https://github.com/serde-rs/json
 //! [Postcard]: https://github.com/jamesmunns/postcard
@@ -89,13 +90,16 @@
 //! [DynamoDB Items]: https://docs.rs/serde_dynamo
 //! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
 //! [Hjson]: https://github.com/Canop/deser-hjson
+//! [CSV]: https://docs.rs/csv

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

 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.186")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.202")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
+// Show which crate feature enables conditionally compiled APIs in documentation.
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
 // Unstable functionality only if the user asks for it. For tracking and
 // discussion of these features please refer to this issue:
 //
@@ -114,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,
@@ -127,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,
@@ -166,22 +171,25 @@ mod lib {
        pub use std::*;
    }

-    pub use self::core::{cmp, iter, mem, num, ptr, slice, str};
    pub use self::core::{f32, f64};
    pub use self::core::{i16, i32, i64, i8, isize};
+    pub use self::core::{iter, num, ptr, str};
    pub use self::core::{u16, u32, u64, u8, usize};

+    #[cfg(any(feature = "std", feature = "alloc"))]
+    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")))]
@@ -267,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
@@ -319,6 +330,7 @@ extern crate serde_derive;

 /// Derive macro available if serde is built with `features = ["derive"]`.
 #[cfg(feature = "serde_derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub use serde_derive::{Deserialize, Serialize};

 #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
@@ -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>,
        {
@@ -154,9 +154,7 @@ macro_rules! forward_to_deserialize_any_helper {
        forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
    };
    (i128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
-            forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
-        }
+        forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
    };
    (u8<$l:tt, $v:ident>) => {
        forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
@@ -171,9 +169,7 @@ macro_rules! forward_to_deserialize_any_helper {
        forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
    };
    (u128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
-            forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
-        }
+        forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
    };
    (f32<$l:tt, $v:ident>) => {
        forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}
@@ -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));
@@ -52,10 +52,12 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
        serialize_i16: i16,
        serialize_i32: i32,
        serialize_i64: i64,
+        serialize_i128: i128,
        serialize_u8: u8,
        serialize_u16: u16,
        serialize_u32: u32,
        serialize_u64: u64,
+        serialize_u128: u128,
        serialize_f32: f32,
        serialize_f64: f64,
        serialize_char: char,
@@ -63,13 +65,6 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
        serialize_unit_struct: &'static str,
    }

-    serde_if_integer128! {
-        fmt_primitives! {
-            serialize_i128: i128,
-            serialize_u128: u128,
-        }
-    }
-
    fn serialize_unit_variant(
        self,
        _name: &'static str,
@@ -79,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)
    }
@@ -94,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)
    }
@@ -105,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,
@@ -113,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)
    }
@@ -166,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)
    }
@@ -24,20 +24,17 @@ primitive_impl!(i8, serialize_i8);
 primitive_impl!(i16, serialize_i16);
 primitive_impl!(i32, serialize_i32);
 primitive_impl!(i64, serialize_i64);
+primitive_impl!(i128, serialize_i128);
 primitive_impl!(usize, serialize_u64 as u64);
 primitive_impl!(u8, serialize_u8);
 primitive_impl!(u16, serialize_u16);
 primitive_impl!(u32, serialize_u32);
 primitive_impl!(u64, serialize_u64);
+primitive_impl!(u128, serialize_u128);
 primitive_impl!(f32, serialize_f32);
 primitive_impl!(f64, serialize_f64);
 primitive_impl!(char, serialize_char);

-serde_if_integer128! {
-    primitive_impl!(i128, serialize_i128);
-    primitive_impl!(u128, serialize_u128);
-}
-
 ////////////////////////////////////////////////////////////////////////////////

 impl Serialize for str {
@@ -51,6 +48,7 @@ impl Serialize for str {
 }

 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl Serialize for String {
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -73,6 +71,7 @@ impl<'a> Serialize for fmt::Arguments<'a> {
 ////////////////////////////////////////////////////////////////////////////////

 #[cfg(any(feature = "std", not(no_core_cstr)))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for CStr {
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -84,6 +83,7 @@ impl Serialize for CStr {
 }

 #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl Serialize for CString {
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -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
@@ -182,9 +185,13 @@ where
    }
 }

-#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
+#[cfg(not(no_relaxed_trait_bounds))]
 macro_rules! seq_impl {
-    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
        where
            T: Serialize,
@@ -200,9 +207,13 @@ macro_rules! seq_impl {
    }
 }

-#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
+#[cfg(no_relaxed_trait_bounds)]
 macro_rules! seq_impl {
-    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
        where
            T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
@@ -219,23 +230,41 @@ macro_rules! seq_impl {
    }
 }

-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(BinaryHeap<T: Ord>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    BinaryHeap<T: Ord>
+}

-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(BTreeSet<T: Ord>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    BTreeSet<T: Ord>
+}

-#[cfg(feature = "std")]
-seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>);
+seq_impl! {
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    HashSet<T: Eq + Hash, H: BuildHasher>
+}

-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(LinkedList<T>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    LinkedList<T>
+}

-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(Vec<T>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    Vec<T>
+}

-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(VecDeque<T>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    VecDeque<T>
+}

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

@@ -342,6 +371,7 @@ impl Serialize for () {
 }

 #[cfg(feature = "unstable")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
 impl Serialize for ! {
    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -397,9 +427,13 @@ tuple_impls! {

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

-#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
+#[cfg(not(no_relaxed_trait_bounds))]
 macro_rules! map_impl {
-    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
        where
            K: Serialize,
@@ -416,9 +450,13 @@ macro_rules! map_impl {
    }
 }

-#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
+#[cfg(no_relaxed_trait_bounds)]
 macro_rules! map_impl {
-    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
        where
            K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
@@ -436,20 +474,26 @@ macro_rules! map_impl {
    }
 }

-#[cfg(any(feature = "std", feature = "alloc"))]
-map_impl!(BTreeMap<K: Ord, V>);
+map_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    BTreeMap<K: Ord, V>
+}

-#[cfg(feature = "std")]
-map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
+map_impl! {
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    HashMap<K: Eq + Hash, V, H: BuildHasher>
+}

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

 macro_rules! deref_impl {
    (
-        $(#[doc = $doc:tt])*
+        $(#[$attr:meta])*
        <$($desc:tt)+
    ) => {
-        $(#[doc = $doc])*
+        $(#[$attr])*
        impl <$($desc)+ {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -462,13 +506,20 @@ macro_rules! deref_impl {
    };
 }

-deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize);
-deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
+deref_impl! {
+    <'a, T> Serialize for &'a T where T: ?Sized + Serialize
+}

-#[cfg(any(feature = "std", feature = "alloc"))]
-deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
+deref_impl! {
+    <'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> Serialize for Box<T> where T: ?Sized + Serialize
+}

-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
 deref_impl! {
    /// This impl requires the [`"rc"`] Cargo feature of Serde.
    ///
@@ -478,10 +529,11 @@ deref_impl! {
    /// repeated data.
    ///
    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    <T: ?Sized> Serialize for Rc<T> where T: Serialize
+    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
+    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
+    <T> Serialize for Rc<T> where T: ?Sized + Serialize
 }

-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
 deref_impl! {
    /// This impl requires the [`"rc"`] Cargo feature of Serde.
    ///
@@ -491,11 +543,16 @@ deref_impl! {
    /// repeated data.
    ///
    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    <T: ?Sized> Serialize for Arc<T> where T: Serialize
+    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
+    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
+    <T> Serialize for Arc<T> where T: ?Sized + Serialize
 }

-#[cfg(any(feature = "std", feature = "alloc"))]
-deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
+deref_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    <'a, T> Serialize for Cow<'a, T> where T: ?Sized + Serialize + ToOwned
+}

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

@@ -503,9 +560,13 @@ deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwne
 ///
 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<T: ?Sized> Serialize for RcWeak<T>
+#[cfg_attr(
+    doc_cfg,
+    doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
+)]
+impl<T> Serialize for RcWeak<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -519,9 +580,13 @@ where
 ///
 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<T: ?Sized> Serialize for ArcWeak<T>
+#[cfg_attr(
+    doc_cfg,
+    doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
+)]
+impl<T> Serialize for ArcWeak<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -553,6 +618,7 @@ nonzero_integers! {
    NonZeroU16,
    NonZeroU32,
    NonZeroU64,
+    NonZeroU128,
    NonZeroUsize,
 }

@@ -562,22 +628,10 @@ nonzero_integers! {
    NonZeroI16,
    NonZeroI32,
    NonZeroI64,
+    NonZeroI128,
    NonZeroIsize,
 }

-// Currently 128-bit integers do not work on Emscripten targets so we need an
-// additional `#[cfg]`
-serde_if_integer128! {
-    nonzero_integers! {
-        NonZeroU128,
-    }
-
-    #[cfg(not(no_num_nonzero_signed))]
-    nonzero_integers! {
-        NonZeroI128,
-    }
-}
-
 impl<T> Serialize for Cell<T>
 where
    T: Serialize + Copy,
@@ -590,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
@@ -606,9 +660,10 @@ where
 }

 #[cfg(feature = "std")]
-impl<T: ?Sized> Serialize for Mutex<T>
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+impl<T> Serialize for Mutex<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -622,9 +677,10 @@ where
 }

 #[cfg(feature = "std")]
-impl<T: ?Sized> Serialize for RwLock<T>
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+impl<T> Serialize for RwLock<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -675,6 +731,7 @@ impl Serialize for Duration {
 ////////////////////////////////////////////////////////////////////////////////

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for SystemTime {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -719,6 +776,7 @@ macro_rules! serialize_display_bounded_length {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::IpAddr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -789,6 +847,7 @@ fn test_format_u8() {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::Ipv4Addr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -813,6 +872,7 @@ impl Serialize for net::Ipv4Addr {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::Ipv6Addr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -829,6 +889,7 @@ impl Serialize for net::Ipv6Addr {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::SocketAddr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -853,6 +914,7 @@ impl Serialize for net::SocketAddr {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::SocketAddrV4 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -869,6 +931,7 @@ impl Serialize for net::SocketAddrV4 {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::SocketAddrV6 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -890,6 +953,7 @@ impl Serialize for net::SocketAddrV6 {
 ////////////////////////////////////////////////////////////////////////////////

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for Path {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -903,6 +967,7 @@ impl Serialize for Path {
 }

 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for PathBuf {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -913,6 +978,7 @@ impl Serialize for PathBuf {
 }

 #[cfg(all(feature = "std", any(unix, windows)))]
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
 impl Serialize for OsStr {
    #[cfg(unix)]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -935,6 +1001,7 @@ impl Serialize for OsStr {
 }

 #[cfg(all(feature = "std", any(unix, windows)))]
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
 impl Serialize for OsString {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -959,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,
@@ -979,6 +1060,7 @@ macro_rules! atomic_impl {
    ($($ty:ident $size:expr)*) => {
        $(
            #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
+            #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", target_has_atomic = $size))))]
            impl Serialize for $ty {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
@@ -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\>
@@ -488,30 +488,27 @@ pub trait Serializer: Sized {
    /// ```
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;

-    serde_if_integer128! {
-        /// Serialize an `i128` value.
-        ///
-        /// ```edition2021
-        /// # use serde::Serializer;
-        /// #
-        /// # serde::__private_serialize!();
-        /// #
-        /// impl Serialize for i128 {
-        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        ///     where
-        ///         S: Serializer,
-        ///     {
-        ///         serializer.serialize_i128(*self)
-        ///     }
-        /// }
-        /// ```
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-            let _ = v;
-            Err(Error::custom("i128 is not supported"))
-        }
+    /// Serialize an `i128` value.
+    ///
+    /// ```edition2021
+    /// # use serde::Serializer;
+    /// #
+    /// # serde::__private_serialize!();
+    /// #
+    /// impl Serialize for i128 {
+    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    ///     where
+    ///         S: Serializer,
+    ///     {
+    ///         serializer.serialize_i128(*self)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+        let _ = v;
+        Err(Error::custom("i128 is not supported"))
    }

    /// Serialize a `u8` value.
@@ -598,30 +595,27 @@ pub trait Serializer: Sized {
    /// ```
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;

-    serde_if_integer128! {
-        /// Serialize a `u128` value.
-        ///
-        /// ```edition2021
-        /// # use serde::Serializer;
-        /// #
-        /// # serde::__private_serialize!();
-        /// #
-        /// impl Serialize for u128 {
-        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        ///     where
-        ///         S: Serializer,
-        ///     {
-        ///         serializer.serialize_u128(*self)
-        ///     }
-        /// }
-        /// ```
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-            let _ = v;
-            Err(Error::custom("u128 is not supported"))
-        }
+    /// Serialize a `u128` value.
+    ///
+    /// ```edition2021
+    /// # use serde::Serializer;
+    /// #
+    /// # serde::__private_serialize!();
+    /// #
+    /// impl Serialize for u128 {
+    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    ///     where
+    ///         S: Serializer,
+    ///     {
+    ///         serializer.serialize_u128(*self)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        let _ = v;
+        Err(Error::custom("u128 is not supported"))
    }

    /// Serialize an `f32` value.
@@ -802,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.
    ///
@@ -897,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) }`.
    ///
@@ -931,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,
@@ -939,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
@@ -1176,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};
@@ -1213,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};
@@ -1352,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())
    }
@@ -1385,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.
@@ -1499,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>;
@@ -1599,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>;
@@ -1644,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>;
@@ -1702,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>;
@@ -1773,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.
    ///
@@ -1783,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.
    ///
@@ -1804,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)
@@ -1862,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;
@@ -1928,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,12 @@
 [package]
 name = "serde_derive"
-version = "1.0.186" # remember to update html_root_url
+version = "1.0.202"
 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"
+exclude = ["build.rs"]
 homepage = "https://serde.rs"
 keywords = ["serde", "serialization", "no_std", "derive"]
 license = "MIT OR Apache-2.0"
@@ -21,9 +23,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" }
@@ -0,0 +1,8 @@
+fn main() {
+    // Warning: build.rs is not published to crates.io.
+
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rustc-cfg=check_cfg");
+    println!("cargo:rustc-check-cfg=cfg(check_cfg)");
+    println!("cargo:rustc-check-cfg=cfg(exhaustive)");
+}
@@ -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))]
                _ => {}
            }
        }
@@ -1737,7 +1737,6 @@ fn deserialize_untagged_enum_after(
                quote!(__deserializer),
            ))
        });
-    let attempts = first_attempt.into_iter().chain(attempts);
    // TODO this message could be better by saving the errors from the failed
    // attempts. The heuristic used by TOML was to count the number of fields
    // processed before an error, and use the error that happened after the
@@ -1750,10 +1749,23 @@ fn deserialize_untagged_enum_after(
    );
    let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);

+    // Ignore any error associated with non-untagged deserialization so that we
+    // can fall through to the untagged variants. This may be infallible so we
+    // need to provide the error type.
+    let first_attempt = first_attempt.map(|expr| {
+        quote! {
+            if let _serde::__private::Result::<_, __D::Error>::Ok(__ok) = (|| #expr)() {
+                return _serde::__private::Ok(__ok);
+            }
+        }
+    });
+
    quote_block! {
        let __content = <_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)?;
        let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content);

+        #first_attempt
+
        #(
            if let _serde::__private::Ok(__ok) = #attempts {
                return _serde::__private::Ok(__ok);
@@ -1828,7 +1840,7 @@ fn deserialize_internally_tagged_variant(
            let this_value = &params.this_value;
            let type_name = params.type_name();
            let variant_name = variant.ident.to_string();
-            let default = variant.fields.get(0).map(|field| {
+            let default = variant.fields.first().map(|field| {
                let default = Expr(expr_is_missing(field, cattrs));
                quote!((#default))
            });
@@ -1873,7 +1885,7 @@ fn deserialize_untagged_variant(
            let this_value = &params.this_value;
            let type_name = params.type_name();
            let variant_name = variant.ident.to_string();
-            let default = variant.fields.get(0).map(|field| {
+            let default = variant.fields.first().map(|field| {
                let default = Expr(expr_is_missing(field, cattrs));
                quote!((#default))
            });
@@ -185,8 +185,8 @@ impl Name {

 #[derive(Copy, Clone)]
 pub struct RenameAllRules {
-    serialize: RenameRule,
-    deserialize: RenameRule,
+    pub serialize: RenameRule,
+    pub deserialize: RenameRule,
 }

 impl RenameAllRules {
@@ -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());
@@ -84,7 +84,7 @@ impl ReplaceReceiver<'_> {
            self.visit_type_mut_impl(ty);
            return;
        };
-        *ty = self.self_ty(span).into();
+        *ty = Type::Path(self.self_ty(span));
    }

    // `Self::Assoc` -> `<Receiver>::Assoc`
@@ -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,8 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.186")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.202")]
+#![cfg_attr(not(check_cfg), allow(unexpected_cfgs))]
 // Ignored clippy lints
 #![allow(
    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
@@ -50,7 +51,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;

@@ -1,9 +1,10 @@
 [package]
 name = "serde_derive_internals"
-version = "0.28.0" # remember to update html_root_url
+version = "0.29.1"
 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"]
@@ -1,9 +1,17 @@
 use std::path::Path;

 fn main() {
+    // Warning: build.rs is not published to crates.io.
+
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rerun-if-changed=src/mod.rs");

+    println!("cargo:rustc-cfg=check_cfg");
+    println!("cargo:rustc-check-cfg=cfg(check_cfg)");
+    println!("cargo:rustc-check-cfg=cfg(exhaustive)");
+    println!("cargo:rustc-check-cfg=cfg(serde_build_from_git)");
+    println!("cargo:rustc-check-cfg=cfg(feature, values(\"deserialize_in_place\"))");
+
    // Sometimes on Windows the git checkout does not correctly wire up the
    // symlink from serde_derive_internals/src to serde_derive/src/internals.
    // When this happens we'll just build based on relative paths within the git
@@ -1,4 +1,5 @@
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.28.0")]
+#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.29.1")]
+#![cfg_attr(not(check_cfg), allow(unexpected_cfgs))]
 // Ignored clippy lints
 #![allow(
    clippy::cognitive_complexity,
@@ -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,
    },
 }
@@ -2380,6 +2380,68 @@ fn test_partially_untagged_enum_desugared() {
    );
 }

+#[test]
+fn test_partially_untagged_internally_tagged_enum() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A,
+        B,
+        #[serde(untagged)]
+        Var(u32),
+    }
+
+    let data = Data::A;
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::MapEnd,
+        ],
+    );
+
+    let data = Data::Var(42);
+
+    assert_de_tokens(&data, &[Token::U32(42)]);
+
+    // TODO test error output
+}
+
+#[test]
+fn test_partially_untagged_adjacently_tagged_enum() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t", content = "c")]
+    enum Data {
+        A(u32),
+        B,
+        #[serde(untagged)]
+        Var(u32),
+    }
+
+    let data = Data::A(7);
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::Str("c"),
+            Token::U32(7),
+            Token::MapEnd,
+        ],
+    );
+
+    let data = Data::Var(42);
+
+    assert_de_tokens(&data, &[Token::U32(42)]);
+
+    // TODO test error output
+}
+
 #[test]
 fn test_flatten_option() {
    #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2719,7 +2781,7 @@ fn test_expecting_message_externally_tagged_enum() {
    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
    assert_de_tokens_error::<Enum>(
        &[Token::Enum { name: "Enum" }, Token::Unit],
-        r#"invalid type: unit value, expected variant identifier"#,
+        "invalid type: unit value, expected variant identifier",
    );
 }

@@ -2740,7 +2802,7 @@ fn test_expecting_message_internally_tagged_enum() {
    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
    assert_de_tokens_error::<Enum>(
        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
-        r#"invalid type: unit value, expected variant identifier"#,
+        "invalid type: unit value, expected variant identifier",
    );
 }

@@ -2766,7 +2828,7 @@ fn test_expecting_message_adjacently_tagged_enum() {
    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
    assert_de_tokens_error::<Enum>(
        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
-        r#"invalid type: unit value, expected variant of enum Enum"#,
+        "invalid type: unit value, expected variant of enum Enum",
    );
 }

@@ -2779,7 +2841,7 @@ fn test_expecting_message_untagged_tagged_enum() {
        Untagged,
    }

-    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], r#"something strange..."#);
+    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], "something strange...");
 }

 #[test]
@@ -2800,7 +2862,7 @@ fn test_expecting_message_identifier_enum() {

    assert_de_tokens_error::<FieldEnum>(
        &[Token::Unit],
-        r#"invalid type: unit value, expected something strange..."#,
+        "invalid type: unit value, expected something strange...",
    );

    assert_de_tokens_error::<FieldEnum>(
@@ -2809,12 +2871,12 @@ fn test_expecting_message_identifier_enum() {
            Token::Str("Unknown"),
            Token::None,
        ],
-        r#"invalid type: map, expected something strange..."#,
+        "invalid type: map, expected something strange...",
    );

    assert_de_tokens_error::<VariantEnum>(
        &[Token::Unit],
-        r#"invalid type: unit value, expected something strange..."#,
+        "invalid type: unit value, expected something strange...",
    );

    assert_de_tokens_error::<VariantEnum>(
@@ -2825,7 +2887,7 @@ fn test_expecting_message_identifier_enum() {
            Token::Str("Unknown"),
            Token::None,
        ],
-        r#"invalid type: map, expected something strange..."#,
+        "invalid type: map, expected something strange...",
    );
 }

@@ -11,6 +11,7 @@
 #![cfg_attr(feature = "unstable", feature(never_type))]

 use fnv::FnvHasher;
+use serde::de::value::{F32Deserializer, F64Deserializer};
 use serde::de::{Deserialize, DeserializeOwned, Deserializer, IntoDeserializer};
 use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Configure, Token};
@@ -22,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};
@@ -832,6 +833,26 @@ fn test_f64() {
    test(1.11, &[Token::F64(1.11)]);
 }

+#[test]
+fn test_nan() {
+    let f32_deserializer = F32Deserializer::<serde::de::value::Error>::new;
+    let f64_deserializer = F64Deserializer::<serde::de::value::Error>::new;
+
+    let pos_f32_nan = f32_deserializer(f32::NAN.copysign(1.0));
+    let pos_f64_nan = f64_deserializer(f64::NAN.copysign(1.0));
+    assert!(f32::deserialize(pos_f32_nan).unwrap().is_sign_positive());
+    assert!(f32::deserialize(pos_f64_nan).unwrap().is_sign_positive());
+    assert!(f64::deserialize(pos_f32_nan).unwrap().is_sign_positive());
+    assert!(f64::deserialize(pos_f64_nan).unwrap().is_sign_positive());
+
+    let neg_f32_nan = f32_deserializer(f32::NAN.copysign(-1.0));
+    let neg_f64_nan = f64_deserializer(f64::NAN.copysign(-1.0));
+    assert!(f32::deserialize(neg_f32_nan).unwrap().is_sign_negative());
+    assert!(f32::deserialize(neg_f64_nan).unwrap().is_sign_negative());
+    assert!(f64::deserialize(neg_f32_nan).unwrap().is_sign_negative());
+    assert!(f64::deserialize(neg_f64_nan).unwrap().is_sign_negative());
+}
+
 #[test]
 fn test_char() {
    test('a', &[Token::Char('a')]);
@@ -1877,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(
@@ -2004,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,15 @@ 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",
+    );
+}
+
+#[test]
+fn test_nan_no_decimal_point() {
+    assert_de_tokens_error::<isize>(
+        &[Token::F32(f32::NAN)],
+        "invalid type: floating point `NaN`, expected isize",
    );
 }

@@ -1459,7 +1467,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 +1484,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 +1498,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 +1515,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,
@@ -1516,13 +1524,12 @@ fn test_systemtime_overflow_struct() {
    );
 }

-#[cfg(systemtime_checked_add)]
 #[test]
 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>
@@ -2,10 +2,17 @@ error[E0609]: no field `b` on type `&remote::S`
  --> tests/ui/remote/unknown_field.rs:12:5
   |
 12 |     b: u8,
-   |     ^ help: a field with a similar name exists: `a`
+   |     ^ 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 |     b: u8,
-   |     ^ help: a field with a similar name exists: `a`
+   |     ^ `remote::S` does not have this field
+   |
+   = note: all struct fields are already assigned
@@ -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())]
-  |                     +++++++