Release 1.0.148

Improve error message on remote derive duplicate generics

.gitattributes

@@ -0,0 +1 @@
+test_suite/tests/expand/*.expanded.rs linguist-generated

.github/workflows/ci.yml

@@ -5,6 +5,9 @@ on:
   pull_request:
   schedule: [cron: "40 1 * * *"]
 
+permissions:
+  contents: read
+
 env:
   RUSTFLAGS: -Dwarnings
 
@@ -12,16 +15,22 @@ jobs:
   test:
     name: Test suite
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable
+      - uses: dtolnay/install@cargo-expand
+        if: github.event_name != 'pull_request'
+      - run: cd test_suite && cargo test --features expandtest --test expandtest -- --include-ignored
+        if: github.event_name != 'pull_request'
 
   windows:
     name: Test suite (windows)
     runs-on: windows-latest
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
 
@@ -32,8 +41,9 @@ jobs:
       fail-fast: false
       matrix:
         rust: [stable, beta]
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -49,8 +59,9 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu, windows]
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd serde && cargo build
       - run: cd serde && cargo build --no-default-features
@@ -59,16 +70,21 @@ jobs:
       - run: cd serde && cargo test --features derive,rc,unstable
       - run: cd test_suite/no_std && cargo build
         if: matrix.os != 'windows'
+      - run: cd serde_derive && cargo check --tests
+        env:
+          RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
+        if: matrix.os != 'windows'
 
   msrv:
     name: Rust 1.13.0
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.13.0
       - name: Get timestamp for cache
         id: date
-        run: echo ::set-output name=yearmo::$(date +%Y%m)
+        run: echo yearmo=$(date +%Y%m) >> $GITHUB_OUTPUT
       - uses: actions/cache@v1
         with:
           path: ~/.cargo/registry/index
@@ -84,8 +100,9 @@ jobs:
       fail-fast: false
       matrix:
         rust: [1.19.0, 1.20.0, 1.21.0, 1.25.0, 1.26.0, 1.34.0]
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -99,8 +116,9 @@ jobs:
       fail-fast: false
       matrix:
         rust: [1.27.0, 1.28.0]
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -112,8 +130,9 @@ jobs:
   derive:
     name: Rust 1.31.0
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.31.0
       - run: cd serde && cargo check --no-default-features
       - run: cd serde && cargo check
@@ -122,16 +141,18 @@ jobs:
   alloc:
     name: Rust 1.36.0
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.36.0
       - run: cd serde && cargo build --no-default-features --features alloc
 
   emscripten:
     name: Emscripten
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - uses: actions/setup-node@v1
         with:
@@ -153,8 +174,9 @@ jobs:
     name: Clippy
     runs-on: ubuntu-latest
     if: github.event_name != 'pull_request'
+    timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - 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
@@ -162,3 +184,27 @@ jobs:
       - run: cd serde_test && cargo clippy -- -Dclippy::all -Dclippy::pedantic
       - run: cd test_suite && cargo clippy --tests --features unstable -- -Dclippy::all -Dclippy::pedantic
       - run: cd test_suite/no_std && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+
+  miri:
+    name: Miri
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@miri
+      - run: cd serde && cargo miri test --features derive,rc,unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+      - run: cd test_suite && cargo miri test --features unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+
+  outdated:
+    name: Outdated
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1

README.md

@@ -77,17 +77,20 @@ fn main() {
 
 Serde is one of the most widely used Rust libraries so any place that Rustaceans
 congregate will be able to help you out. For chat, consider trying the
-[#general] or [#beginners] channels of the unofficial community Discord, the
-[#rust-usage] channel of the official Rust Project Discord, or the
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
-acceptable to file a support issue in this repo but they tend not to get as many
-eyes as any of the above and may get closed without a response after some time.
+[#rust-questions] or [#rust-beginners] channels of the unofficial community
+Discord (invite: <https://discord.gg/rust-lang-community>), the [#rust-usage] or
+[#beginners] channels of the official Rust Project Discord (invite:
+<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
+asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
+[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
+[Discourse forum][discourse]. It's acceptable to file a support issue in this
+repo but they tend not to get as many eyes as any of the above and may get
+closed without a response after some time.
 
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
+[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
 [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
 [zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
 [stackoverflow]: https://stackoverflow.com/questions/tagged/rust
 [/r/rust]: https://www.reddit.com/r/rust

crates-io.md

@@ -45,17 +45,20 @@ fn main() {
 
 Serde is one of the most widely used Rust libraries so any place that Rustaceans
 congregate will be able to help you out. For chat, consider trying the
-[#general] or [#beginners] channels of the unofficial community Discord, the
-[#rust-usage] channel of the official Rust Project Discord, or the
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
-acceptable to file a support issue in this repo but they tend not to get as many
-eyes as any of the above and may get closed without a response after some time.
+[#rust-questions] or [#rust-beginners] channels of the unofficial community
+Discord (invite: <https://discord.gg/rust-lang-community>, the [#rust-usage] or
+[#beginners] channels of the official Rust Project Discord (invite:
+<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
+asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
+[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
+[Discourse forum][discourse]. It's acceptable to file a support issue in this
+repo but they tend not to get as many eyes as any of the above and may get
+closed without a response after some time.
 
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
+[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
 [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
 [zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
 [stackoverflow]: https://stackoverflow.com/questions/tagged/rust
 [/r/rust]: https://www.reddit.com/r/rust

serde/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.13.0"

serde/Cargo.toml

@@ -1,21 +1,21 @@
 [package]
 name = "serde"
-version = "1.0.133" # remember to update html_root_url and serde_derive dependency
+version = "1.0.148" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.15"
-license = "MIT OR Apache-2.0"
-description = "A generic serialization/deserialization framework"
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
-documentation = "https://docs.serde.rs/serde/"
-keywords = ["serde", "serialization", "no_std"]
-categories = ["encoding"]
-readme = "crates-io.md"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 build = "build.rs"
+categories = ["encoding", "no-std"]
+description = "A generic serialization/deserialization framework"
+documentation = "https://docs.serde.rs/serde/"
+homepage = "https://serde.rs"
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization", "no_std"]
+license = "MIT OR Apache-2.0"
+readme = "crates-io.md"
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.13"
 
 [dependencies]
-serde_derive = { version = "=1.0.133", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.148", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

serde/build.rs

@@ -17,37 +17,38 @@ fn main() {
     // std::collections::Bound was stabilized in Rust 1.17
     // but it was moved to core::ops later in Rust 1.26:
     // https://doc.rust-lang.org/core/ops/enum.Bound.html
-    if minor >= 26 {
-        println!("cargo:rustc-cfg=ops_bound");
-    } else if minor >= 17 && cfg!(feature = "std") {
-        println!("cargo:rustc-cfg=collections_bound");
+    if minor < 26 {
+        println!("cargo:rustc-cfg=no_ops_bound");
+        if minor < 17 {
+            println!("cargo:rustc-cfg=no_collections_bound");
+        }
     }
 
     // core::cmp::Reverse stabilized in Rust 1.19:
     // https://doc.rust-lang.org/stable/core/cmp/struct.Reverse.html
-    if minor >= 19 {
-        println!("cargo:rustc-cfg=core_reverse");
+    if minor < 19 {
+        println!("cargo:rustc-cfg=no_core_reverse");
     }
 
     // CString::into_boxed_c_str and PathBuf::into_boxed_path stabilized in Rust 1.20:
     // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
     // https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.into_boxed_path
-    if minor >= 20 {
-        println!("cargo:rustc-cfg=de_boxed_c_str");
-        println!("cargo:rustc-cfg=de_boxed_path");
+    if minor < 20 {
+        println!("cargo:rustc-cfg=no_de_boxed_c_str");
+        println!("cargo:rustc-cfg=no_de_boxed_path");
     }
 
     // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:
     // https://doc.rust-lang.org/std/rc/struct.Rc.html#impl-From<Box<T>>
     // https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-From<Box<T>>
-    if minor >= 21 {
-        println!("cargo:rustc-cfg=de_rc_dst");
+    if minor < 21 {
+        println!("cargo:rustc-cfg=no_de_rc_dst");
     }
 
     // Duration available in core since Rust 1.25:
     // https://blog.rust-lang.org/2018/03/29/Rust-1.25.html#library-stabilizations
-    if minor >= 25 {
-        println!("cargo:rustc-cfg=core_duration");
+    if minor < 25 {
+        println!("cargo:rustc-cfg=no_core_duration");
     }
 
     // 128-bit integers stabilized in Rust 1.26:
@@ -56,56 +57,56 @@ fn main() {
     // 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 minor >= 26 && (!emscripten || minor >= 40) {
-        println!("cargo:rustc-cfg=integer128");
+    if minor < 26 || emscripten && minor < 40 {
+        println!("cargo:rustc-cfg=no_integer128");
     }
 
     // Inclusive ranges methods stabilized in Rust 1.27:
     // https://github.com/rust-lang/rust/pull/50758
     // Also Iterator::try_for_each:
     // https://blog.rust-lang.org/2018/06/21/Rust-1.27.html#library-stabilizations
-    if minor >= 27 {
-        println!("cargo:rustc-cfg=range_inclusive");
-        println!("cargo:rustc-cfg=iterator_try_fold");
+    if minor < 27 {
+        println!("cargo:rustc-cfg=no_range_inclusive");
+        println!("cargo:rustc-cfg=no_iterator_try_fold");
     }
 
     // Non-zero integers stabilized in Rust 1.28:
     // https://blog.rust-lang.org/2018/08/02/Rust-1.28.html#library-stabilizations
-    if minor >= 28 {
-        println!("cargo:rustc-cfg=num_nonzero");
+    if minor < 28 {
+        println!("cargo:rustc-cfg=no_num_nonzero");
     }
 
     // Current minimum supported version of serde_derive crate is Rust 1.31.
-    if minor >= 31 {
-        println!("cargo:rustc-cfg=serde_derive");
+    if minor < 31 {
+        println!("cargo:rustc-cfg=no_serde_derive");
     }
 
     // TryFrom, Atomic types, non-zero signed integers, and SystemTime::checked_add
     // stabilized in Rust 1.34:
     // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
     // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#library-stabilizations
-    if minor >= 34 {
-        println!("cargo:rustc-cfg=core_try_from");
-        println!("cargo:rustc-cfg=num_nonzero_signed");
-        println!("cargo:rustc-cfg=systemtime_checked_add");
+    if minor < 34 {
+        println!("cargo:rustc-cfg=no_core_try_from");
+        println!("cargo:rustc-cfg=no_num_nonzero_signed");
+        println!("cargo:rustc-cfg=no_systemtime_checked_add");
+    }
 
-        // Whitelist of archs that support std::sync::atomic module. Ideally we
-        // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
-        // Instead this is based on rustc's compiler/rustc_target/src/spec/*.rs.
-        let has_atomic64 = target.starts_with("x86_64")
-            || target.starts_with("i686")
-            || target.starts_with("aarch64")
-            || target.starts_with("powerpc64")
-            || target.starts_with("sparc64")
-            || target.starts_with("mips64el")
-            || target.starts_with("riscv64");
-        let has_atomic32 = has_atomic64 || emscripten;
-        if has_atomic64 {
-            println!("cargo:rustc-cfg=std_atomic64");
-        }
-        if has_atomic32 {
-            println!("cargo:rustc-cfg=std_atomic");
-        }
+    // Whitelist of archs that support std::sync::atomic module. Ideally we
+    // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
+    // Instead this is based on rustc's compiler/rustc_target/src/spec/*.rs.
+    let has_atomic64 = target.starts_with("x86_64")
+        || target.starts_with("i686")
+        || target.starts_with("aarch64")
+        || target.starts_with("powerpc64")
+        || target.starts_with("sparc64")
+        || target.starts_with("mips64el")
+        || target.starts_with("riscv64");
+    let has_atomic32 = has_atomic64 || emscripten;
+    if minor < 34 || !has_atomic64 {
+        println!("cargo:rustc-cfg=no_std_atomic64");
+    }
+    if minor < 34 || !has_atomic32 {
+        println!("cargo:rustc-cfg=no_std_atomic");
     }
 }
 

serde/src/de/format.rs

@@ -0,0 +1,30 @@
+use lib::fmt::{self, Write};
+use lib::str;
+
+pub(super) struct Buf<'a> {
+    bytes: &'a mut [u8],
+    offset: usize,
+}
+
+impl<'a> Buf<'a> {
+    pub fn new(bytes: &'a mut [u8]) -> Self {
+        Buf { bytes, offset: 0 }
+    }
+
+    pub fn as_str(&self) -> &str {
+        let slice = &self.bytes[..self.offset];
+        unsafe { str::from_utf8_unchecked(slice) }
+    }
+}
+
+impl<'a> Write for Buf<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        if self.offset + s.len() > self.bytes.len() {
+            Err(fmt::Error)
+        } else {
+            self.bytes[self.offset..self.offset + s.len()].copy_from_slice(s.as_bytes());
+            self.offset += s.len();
+            Ok(())
+        }
+    }
+}

serde/src/de/ignored_any.rs

@@ -228,7 +228,7 @@ impl<'de> Visitor<'de> for IgnoredAny {
     where
         A: EnumAccess<'de>,
     {
-        data.variant::<IgnoredAny>()?.1.newtype_variant()
+        try!(data.variant::<IgnoredAny>()).1.newtype_variant()
     }
 }
 

serde/src/de/impls.rs

@@ -4,7 +4,7 @@ use de::{
     Deserialize, Deserializer, EnumAccess, Error, SeqAccess, Unexpected, VariantAccess, Visitor,
 };
 
-#[cfg(any(core_duration, feature = "std", feature = "alloc"))]
+#[cfg(any(feature = "std", feature = "alloc", not(no_core_duration)))]
 use de::MapAccess;
 
 use seed::InPlaceSeed;
@@ -81,8 +81,34 @@ impl<'de> Deserialize<'de> for bool {
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! impl_deserialize_num {
-    ($ty:ident, $deserialize:ident $($methods:tt)*) => {
-        impl<'de> Deserialize<'de> for $ty {
+    ($primitive:ident, $nonzero:ident $(cfg($($cfg:tt)*))*, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => {
+        impl_deserialize_num!($primitive, $deserialize $($method!($($val : $visit)*);)*);
+
+        #[cfg(all(not(no_num_nonzero), $($($cfg)*)*))]
+        impl<'de> Deserialize<'de> for num::$nonzero {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct NonZeroVisitor;
+
+                impl<'de> Visitor<'de> for NonZeroVisitor {
+                    type Value = num::$nonzero;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                        formatter.write_str(concat!("a nonzero ", stringify!($primitive)))
+                    }
+
+                    $($($method!(nonzero $primitive $val : $visit);)*)*
+                }
+
+                deserializer.$deserialize(NonZeroVisitor)
+            }
+        }
+    };
+
+    ($primitive:ident, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => {
+        impl<'de> Deserialize<'de> for $primitive {
             #[inline]
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -91,13 +117,13 @@ macro_rules! impl_deserialize_num {
                 struct PrimitiveVisitor;
 
                 impl<'de> Visitor<'de> for PrimitiveVisitor {
-                    type Value = $ty;
+                    type Value = $primitive;
 
                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str(stringify!($ty))
+                        formatter.write_str(stringify!($primitive))
                     }
 
-                    $($methods)*
+                    $($($method!($val : $visit);)*)*
                 }
 
                 deserializer.$deserialize(PrimitiveVisitor)
@@ -116,85 +142,149 @@ macro_rules! num_self {
             Ok(v)
         }
     };
+
+    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if let Some(nonzero) = Self::Value::new(v) {
+                Ok(nonzero)
+            } else {
+                Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
+            }
+        }
+    };
 }
 
 macro_rules! num_as_self {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                Ok(v as Self::Value)
+    ($ty:ident : $visit:ident) => {
+        #[inline]
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(v as Self::Value)
+        }
+    };
+
+    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if let Some(nonzero) = Self::Value::new(v as $primitive) {
+                Ok(nonzero)
+            } else {
+                Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
             }
-        )*
+        }
     };
 }
 
 macro_rules! int_to_int {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
+    ($ty:ident : $visit:ident) => {
+        #[inline]
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if Self::Value::min_value() as i64 <= v as i64
+                && v as i64 <= Self::Value::max_value() as i64
             {
-                if Self::Value::min_value() as i64 <= v as i64 && v as i64 <= Self::Value::max_value() as i64 {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+                Ok(v as Self::Value)
+            } else {
+                Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+            }
+        }
+    };
+
+    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if $primitive::min_value() as i64 <= v as i64
+                && v as i64 <= $primitive::max_value() as i64
+            {
+                if let Some(nonzero) = Self::Value::new(v as $primitive) {
+                    return Ok(nonzero);
                 }
             }
-        )*
+            Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+        }
     };
 }
 
 macro_rules! int_to_uint {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                if 0 <= v && v as u64 <= Self::Value::max_value() as u64 {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+    ($ty:ident : $visit:ident) => {
+        #[inline]
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if 0 <= v && v as u64 <= Self::Value::max_value() as u64 {
+                Ok(v as Self::Value)
+            } else {
+                Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+            }
+        }
+    };
+
+    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if 0 < v && v as u64 <= $primitive::max_value() as u64 {
+                if let Some(nonzero) = Self::Value::new(v as $primitive) {
+                    return Ok(nonzero);
                 }
             }
-        )*
+            Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+        }
     };
 }
 
 macro_rules! uint_to_self {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                if v as u64 <= Self::Value::max_value() as u64 {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
+    ($ty:ident : $visit:ident) => {
+        #[inline]
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if v as u64 <= Self::Value::max_value() as u64 {
+                Ok(v as Self::Value)
+            } else {
+                Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
+            }
+        }
+    };
+
+    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if v as u64 <= $primitive::max_value() as u64 {
+                if let Some(nonzero) = Self::Value::new(v as $primitive) {
+                    return Ok(nonzero);
                 }
             }
-        )*
+            Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
+        }
     };
 }
 
 impl_deserialize_num! {
-    i8, deserialize_i8
+    i8, NonZeroI8 cfg(not(no_num_nonzero_signed)), deserialize_i8
     num_self!(i8:visit_i8);
     int_to_int!(i16:visit_i16 i32:visit_i32 i64:visit_i64);
     uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
 }
 
 impl_deserialize_num! {
-    i16, deserialize_i16
+    i16, NonZeroI16 cfg(not(no_num_nonzero_signed)), deserialize_i16
     num_self!(i16:visit_i16);
     num_as_self!(i8:visit_i8);
     int_to_int!(i32:visit_i32 i64:visit_i64);
@@ -202,7 +292,7 @@ impl_deserialize_num! {
 }
 
 impl_deserialize_num! {
-    i32, deserialize_i32
+    i32, NonZeroI32 cfg(not(no_num_nonzero_signed)), deserialize_i32
     num_self!(i32:visit_i32);
     num_as_self!(i8:visit_i8 i16:visit_i16);
     int_to_int!(i64:visit_i64);
@@ -210,28 +300,28 @@ impl_deserialize_num! {
 }
 
 impl_deserialize_num! {
-    i64, deserialize_i64
+    i64, NonZeroI64 cfg(not(no_num_nonzero_signed)), deserialize_i64
     num_self!(i64:visit_i64);
     num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32);
     uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
 }
 
 impl_deserialize_num! {
-    isize, deserialize_i64
+    isize, NonZeroIsize cfg(not(no_num_nonzero_signed)), deserialize_i64
     num_as_self!(i8:visit_i8 i16:visit_i16);
     int_to_int!(i32:visit_i32 i64:visit_i64);
     uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
 }
 
 impl_deserialize_num! {
-    u8, deserialize_u8
+    u8, NonZeroU8, deserialize_u8
     num_self!(u8:visit_u8);
     int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
     uint_to_self!(u16:visit_u16 u32:visit_u32 u64:visit_u64);
 }
 
 impl_deserialize_num! {
-    u16, deserialize_u16
+    u16, NonZeroU16, deserialize_u16
     num_self!(u16:visit_u16);
     num_as_self!(u8:visit_u8);
     int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
@@ -239,7 +329,7 @@ impl_deserialize_num! {
 }
 
 impl_deserialize_num! {
-    u32, deserialize_u32
+    u32, NonZeroU32, deserialize_u32
     num_self!(u32:visit_u32);
     num_as_self!(u8:visit_u8 u16:visit_u16);
     int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
@@ -247,14 +337,14 @@ impl_deserialize_num! {
 }
 
 impl_deserialize_num! {
-    u64, deserialize_u64
+    u64, NonZeroU64, deserialize_u64
     num_self!(u64:visit_u64);
     num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32);
     int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
 }
 
 impl_deserialize_num! {
-    usize, deserialize_u64
+    usize, NonZeroUsize, deserialize_u64
     num_as_self!(u8:visit_u8 u16:visit_u16);
     int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
     uint_to_self!(u32:visit_u32 u64:visit_u64);
@@ -277,42 +367,62 @@ impl_deserialize_num! {
 }
 
 serde_if_integer128! {
-    impl_deserialize_num! {
-        i128, deserialize_i128
-        num_self!(i128:visit_i128);
-        num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-
-        #[inline]
-        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if v <= i128::max_value() as u128 {
-                Ok(v as i128)
-            } else {
-                Err(Error::invalid_value(Unexpected::Other("u128"), &self))
+    macro_rules! num_128 {
+        ($ty:ident : $visit:ident) => {
+            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                if v as i128 >= Self::Value::min_value() as i128
+                    && v as u128 <= Self::Value::max_value() as u128
+                {
+                    Ok(v as Self::Value)
+                } else {
+                    Err(Error::invalid_value(
+                        Unexpected::Other(stringify!($ty)),
+                        &self,
+                    ))
+                }
             }
-        }
+        };
+
+        (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                if v as i128 >= $primitive::min_value() as i128
+                    && v as u128 <= $primitive::max_value() as u128
+                {
+                    if let Some(nonzero) = Self::Value::new(v as $primitive) {
+                        Ok(nonzero)
+                    } else {
+                        Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
+                    }
+                } else {
+                    Err(Error::invalid_value(
+                        Unexpected::Other(stringify!($ty)),
+                        &self,
+                    ))
+                }
+            }
+        };
     }
 
     impl_deserialize_num! {
-        u128, deserialize_u128
+        i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128
+        num_self!(i128:visit_i128);
+        num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+        num_128!(u128:visit_u128);
+    }
+
+    impl_deserialize_num! {
+        u128, NonZeroU128, deserialize_u128
         num_self!(u128:visit_u128);
         num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
         int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-
-        #[inline]
-        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if 0 <= v {
-                Ok(v as u128)
-            } else {
-                Err(Error::invalid_value(Unexpected::Other("i128"), &self))
-            }
-        }
+        num_128!(i128:visit_i128);
     }
 }
 
@@ -637,10 +747,10 @@ macro_rules! forwarded_impl {
     }
 }
 
-#[cfg(all(feature = "std", de_boxed_c_str))]
+#[cfg(all(feature = "std", not(no_de_boxed_c_str)))]
 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
 
-#[cfg(core_reverse)]
+#[cfg(not(no_core_reverse))]
 forwarded_impl!((T), Reverse<T>, Reverse);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -683,7 +793,6 @@ where
         T::deserialize(deserializer).map(Some)
     }
 
-    #[doc(hidden)]
     fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
     where
         D: Deserializer<'de>,
@@ -1604,7 +1713,7 @@ impl<'de> Deserialize<'de> for PathBuf {
     }
 }
 
-#[cfg(all(feature = "std", de_boxed_path))]
+#[cfg(all(feature = "std", not(no_de_boxed_path)))]
 forwarded_impl!((), Box<Path>, PathBuf::into_boxed_path);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1685,11 +1794,7 @@ forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
 #[cfg(any(feature = "std", feature = "alloc"))]
 forwarded_impl!((), Box<str>, String::into_boxed_str);
 
-#[cfg(all(
-    not(de_rc_dst),
-    feature = "rc",
-    any(feature = "std", feature = "alloc")
-))]
+#[cfg(all(no_de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
 forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1701,11 +1806,7 @@ forwarded_impl! {
     (T), Arc<T>, Arc::new
 }
 
-#[cfg(all(
-    not(de_rc_dst),
-    feature = "rc",
-    any(feature = "std", feature = "alloc")
-))]
+#[cfg(all(no_de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
 forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1772,7 +1873,11 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(
+    not(no_de_rc_dst),
+    feature = "rc",
+    any(feature = "std", feature = "alloc")
+))]
 macro_rules! box_forwarded_impl {
     (
         $(#[doc = $doc:tt])*
@@ -1793,7 +1898,11 @@ macro_rules! box_forwarded_impl {
     };
 }
 
-#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(
+    not(no_de_rc_dst),
+    feature = "rc",
+    any(feature = "std", feature = "alloc")
+))]
 box_forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1805,7 +1914,11 @@ box_forwarded_impl! {
     Rc
 }
 
-#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(
+    not(no_de_rc_dst),
+    feature = "rc",
+    any(feature = "std", feature = "alloc")
+))]
 box_forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1849,7 +1962,7 @@ forwarded_impl!((T), RwLock<T>, RwLock::new);
 //         secs: u64,
 //         nanos: u32,
 //     }
-#[cfg(any(core_duration, feature = "std"))]
+#[cfg(any(feature = "std", not(no_core_duration)))]
 impl<'de> Deserialize<'de> for Duration {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -1898,7 +2011,7 @@ impl<'de> Deserialize<'de> for Duration {
                             b"nanos" => Ok(Field::Nanos),
                             _ => {
                                 let value = ::__private::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
+                                Err(Error::unknown_field(&*value, FIELDS))
                             }
                         }
                     }
@@ -2127,11 +2240,11 @@ impl<'de> Deserialize<'de> for SystemTime {
 
         const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
         let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
-        #[cfg(systemtime_checked_add)]
+        #[cfg(not(no_systemtime_checked_add))]
         let ret = UNIX_EPOCH
             .checked_add(duration)
             .ok_or_else(|| D::Error::custom("overflow deserializing SystemTime"));
-        #[cfg(not(systemtime_checked_add))]
+        #[cfg(no_systemtime_checked_add)]
         let ret = Ok(UNIX_EPOCH + duration);
         ret
     }
@@ -2155,19 +2268,19 @@ where
     where
         D: Deserializer<'de>,
     {
-        let (start, end) = deserializer.deserialize_struct(
+        let (start, end) = try!(deserializer.deserialize_struct(
             "Range",
             range::FIELDS,
             range::RangeVisitor {
                 expecting: "struct Range",
                 phantom: PhantomData,
             },
-        )?;
+        ));
         Ok(start..end)
     }
 }
 
-#[cfg(range_inclusive)]
+#[cfg(not(no_range_inclusive))]
 impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
 where
     Idx: Deserialize<'de>,
@@ -2176,14 +2289,14 @@ where
     where
         D: Deserializer<'de>,
     {
-        let (start, end) = deserializer.deserialize_struct(
+        let (start, end) = try!(deserializer.deserialize_struct(
             "RangeInclusive",
             range::FIELDS,
             range::RangeVisitor {
                 expecting: "struct RangeInclusive",
                 phantom: PhantomData,
             },
-        )?;
+        ));
         Ok(RangeInclusive::new(start, end))
     }
 }
@@ -2238,7 +2351,7 @@ mod range {
                         b"end" => Ok(Field::End),
                         _ => {
                             let value = ::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&value, FIELDS))
+                            Err(Error::unknown_field(&*value, FIELDS))
                         }
                     }
                 }
@@ -2319,7 +2432,7 @@ mod range {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(ops_bound, collections_bound))]
+#[cfg(any(not(no_ops_bound), all(feature = "std", not(no_collections_bound))))]
 impl<'de, T> Deserialize<'de> for Bound<T>
 where
     T: Deserialize<'de>,
@@ -2427,58 +2540,6 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-macro_rules! nonzero_integers {
-    ( $( $T: ident, )+ ) => {
-        $(
-            #[cfg(num_nonzero)]
-            impl<'de> Deserialize<'de> for num::$T {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    let value = try!(Deserialize::deserialize(deserializer));
-                    match <num::$T>::new(value) {
-                        Some(nonzero) => Ok(nonzero),
-                        None => Err(Error::custom("expected a non-zero value")),
-                    }
-                }
-            }
-        )+
-    };
-}
-
-nonzero_integers! {
-    NonZeroU8,
-    NonZeroU16,
-    NonZeroU32,
-    NonZeroU64,
-    NonZeroUsize,
-}
-
-#[cfg(num_nonzero_signed)]
-nonzero_integers! {
-    NonZeroI8,
-    NonZeroI16,
-    NonZeroI32,
-    NonZeroI64,
-    NonZeroIsize,
-}
-
-// Currently 128-bit integers do not work on Emscripten targets so we need an
-// additional `#[cfg]`
-serde_if_integer128! {
-    nonzero_integers! {
-        NonZeroU128,
-    }
-
-    #[cfg(num_nonzero_signed)]
-    nonzero_integers! {
-        NonZeroI128,
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 impl<'de, T, E> Deserialize<'de> for Result<T, E>
 where
     T: Deserialize<'de>,
@@ -2599,7 +2660,7 @@ where
     }
 }
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
     ($($ty:ident)*) => {
         $(
@@ -2615,14 +2676,14 @@ macro_rules! atomic_impl {
     };
 }
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 atomic_impl! {
     AtomicBool
     AtomicI8 AtomicI16 AtomicI32 AtomicIsize
     AtomicU8 AtomicU16 AtomicU32 AtomicUsize
 }
 
-#[cfg(all(feature = "std", std_atomic64))]
+#[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
     AtomicI64 AtomicU64
 }

serde/src/de/mod.rs

@@ -30,7 +30,7 @@
 //! # The Deserializer trait
 //!
 //! [`Deserializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
+//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
 //!
 //! A partial list of well-maintained formats is given on the [Serde
 //! website][data formats].
@@ -104,7 +104,7 @@
 //! [`Deserialize`]: ../trait.Deserialize.html
 //! [`Deserializer`]: ../trait.Deserializer.html
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`bincode`]: https://github.com/servo/bincode
+//! [`postcard`]: https://github.com/jamesmunns/postcard
 //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
@@ -118,6 +118,8 @@ use lib::*;
 
 pub mod value;
 
+#[cfg(not(no_integer128))]
+mod format;
 mod ignored_any;
 mod impls;
 mod utf8;
@@ -563,7 +565,7 @@ pub trait Deserialize<'de>: Sized {
         D: Deserializer<'de>,
     {
         // Default implementation just delegates to `deserialize` impl.
-        *place = Deserialize::deserialize(deserializer)?;
+        *place = try!(Deserialize::deserialize(deserializer));
         Ok(())
     }
 }
@@ -706,6 +708,11 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 ///             where
 ///                 A: SeqAccess<'de>,
 ///             {
+///                 // Decrease the number of reallocations if there are many elements
+///                 if let Some(size_hint) = seq.size_hint() {
+///                    self.0.reserve(size_hint);
+///                 }
+///
 ///                 // Visit each element in the inner array and push it onto
 ///                 // the existing vector.
 ///                 while let Some(elem) = seq.next_element()? {
@@ -855,10 +862,10 @@ where
 /// The `Deserializer` trait supports two entry point styles which enables
 /// different kinds of deserialization.
 ///
-/// 1. The `deserialize` method. Self-describing data formats like JSON are able
-///    to look at the serialized data and tell what it represents. For example
-///    the JSON deserializer may see an opening curly brace (`{`) and know that
-///    it is seeing a map. If the data format supports
+/// 1. The `deserialize_any` method. Self-describing data formats like JSON are
+///    able to look at the serialized data and tell what it represents. For
+///    example the JSON deserializer may see an opening curly brace (`{`) and
+///    know that it is seeing a map. If the data format supports
 ///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever
 ///    type it sees in the input. JSON uses this approach when deserializing
 ///    `serde_json::Value` which is an enum that can represent any JSON
@@ -867,7 +874,7 @@ where
 ///    `Deserializer::deserialize_any`.
 ///
 /// 2. The various `deserialize_*` methods. Non-self-describing formats like
-///    Bincode need to be told what is in the input in order to deserialize it.
+///    Postcard need to be told what is in the input in order to deserialize it.
 ///    The `deserialize_*` methods are hints to the deserializer for how to
 ///    interpret the next piece of input. Non-self-describing formats are not
 ///    able to deserialize something like `serde_json::Value` which relies on
@@ -877,7 +884,7 @@ where
 /// `Deserializer::deserialize_any` unless you need to be told by the
 /// Deserializer what type is in the input. Know that relying on
 /// `Deserializer::deserialize_any` means your data type will be able to
-/// deserialize from self-describing formats only, ruling out Bincode and many
+/// deserialize from self-describing formats only, ruling out Postcard and many
 /// others.
 ///
 /// [Serde data model]: https://serde.rs/data-model.html
@@ -908,7 +915,7 @@ pub trait Deserializer<'de>: Sized {
     /// `Deserializer::deserialize_any` unless you need to be told by the
     /// Deserializer what type is in the input. Know that relying on
     /// `Deserializer::deserialize_any` means your data type will be able to
-    /// deserialize from self-describing formats only, ruling out Bincode and
+    /// deserialize from self-describing formats only, ruling out Postcard and
     /// many others.
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
@@ -1149,7 +1156,7 @@ pub trait Deserializer<'de>: Sized {
     /// Some types have a human-readable form that may be somewhat expensive to
     /// construct, as well as a binary form that is compact and efficient.
     /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Bincode will prefer the
+    /// human-readable one and binary formats like Postcard will prefer the
     /// compact one.
     ///
     /// ```edition2018
@@ -1215,7 +1222,7 @@ pub trait Deserializer<'de>: Sized {
     }
 
     // Not public API.
-    #[cfg(all(serde_derive, any(feature = "std", feature = "alloc")))]
+    #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
     #[doc(hidden)]
     fn __deserialize_content<V>(
         self,
@@ -1366,8 +1373,10 @@ pub trait Visitor<'de>: Sized {
         where
             E: Error,
         {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("i128"), &self))
+            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))
         }
     }
 
@@ -1426,8 +1435,10 @@ pub trait Visitor<'de>: Sized {
         where
             E: Error,
         {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("u128"), &self))
+            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))
         }
     }
 
@@ -1549,7 +1560,7 @@ pub trait Visitor<'de>: Sized {
     /// `Deserializer`.
     ///
     /// This enables zero-copy deserialization of bytes in some formats. For
-    /// example Bincode data containing bytes can be deserialized with zero
+    /// example Postcard data containing bytes can be deserialized with zero
     /// copying into a `&'a [u8]` as long as the input data outlives `'a`.
     ///
     /// The default implementation forwards to `visit_bytes`.

serde/src/de/value.rs

@@ -128,9 +128,7 @@ where
     type Deserializer = UnitDeserializer<E>;
 
     fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer {
-            marker: PhantomData,
-        }
+        UnitDeserializer::new()
     }
 }
 
@@ -141,6 +139,15 @@ pub struct UnitDeserializer<E> {
 
 impl_copy_clone!(UnitDeserializer);
 
+impl<E> UnitDeserializer<E> {
+    #[allow(missing_docs)]
+    pub fn new() -> Self {
+        UnitDeserializer {
+            marker: PhantomData,
+        }
+    }
+}
+
 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
 where
     E: de::Error,
@@ -236,8 +243,15 @@ macro_rules! primitive_deserializer {
             type Deserializer = $name<E>;
 
             fn into_deserializer(self) -> $name<E> {
+                $name::new(self)
+            }
+        }
+
+        impl<E> $name<E> {
+            #[allow(missing_docs)]
+            pub fn new(value: $ty) -> Self {
                 $name {
-                    value: self,
+                    value: value,
                     marker: PhantomData,
                 }
             }
@@ -308,8 +322,15 @@ where
     type Deserializer = U32Deserializer<E>;
 
     fn into_deserializer(self) -> U32Deserializer<E> {
+        U32Deserializer::new(self)
+    }
+}
+
+impl<E> U32Deserializer<E> {
+    #[allow(missing_docs)]
+    pub fn new(value: u32) -> Self {
         U32Deserializer {
-            value: self,
+            value: value,
             marker: PhantomData,
         }
     }
@@ -390,8 +411,15 @@ where
     type Deserializer = StrDeserializer<'a, E>;
 
     fn into_deserializer(self) -> StrDeserializer<'a, E> {
+        StrDeserializer::new(self)
+    }
+}
+
+impl<'a, E> StrDeserializer<'a, E> {
+    #[allow(missing_docs)]
+    pub fn new(value: &'a str) -> Self {
         StrDeserializer {
-            value: self,
+            value: value,
             marker: PhantomData,
         }
     }
@@ -561,8 +589,16 @@ where
     type Deserializer = StringDeserializer<E>;
 
     fn into_deserializer(self) -> StringDeserializer<E> {
+        StringDeserializer::new(self)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> StringDeserializer<E> {
+    #[allow(missing_docs)]
+    pub fn new(value: String) -> Self {
         StringDeserializer {
-            value: self,
+            value: value,
             marker: PhantomData,
         }
     }
@@ -604,7 +640,7 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E>
+impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E>
 where
     E: de::Error,
 {
@@ -656,8 +692,16 @@ where
     type Deserializer = CowStrDeserializer<'a, E>;
 
     fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
+        CowStrDeserializer::new(self)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> CowStrDeserializer<'a, E> {
+    #[allow(missing_docs)]
+    pub fn new(value: Cow<'a, str>) -> Self {
         CowStrDeserializer {
-            value: self,
+            value: value,
             marker: PhantomData,
         }
     }
@@ -1457,7 +1501,7 @@ where
     where
         T: de::DeserializeSeed<'de>,
     {
-        match self.map.next_key_seed(seed)? {
+        match try!(self.map.next_key_seed(seed)) {
             Some(key) => Ok((key, private::map_as_enum(self.map))),
             None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
         }
@@ -1466,6 +1510,41 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+/// A deserializer holding an `EnumAccess`.
+#[derive(Clone, Debug)]
+pub struct EnumAccessDeserializer<A> {
+    access: A,
+}
+
+impl<A> EnumAccessDeserializer<A> {
+    /// Construct a new `EnumAccessDeserializer<A>`.
+    pub fn new(access: A) -> Self {
+        EnumAccessDeserializer { access: access }
+    }
+}
+
+impl<'de, A> de::Deserializer<'de> for EnumAccessDeserializer<A>
+where
+    A: de::EnumAccess<'de>,
+{
+    type Error = A::Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_enum(self.access)
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 mod private {
     use lib::*;
 

serde/src/integer128.rs

@@ -66,7 +66,7 @@
 ///     ($($tt:tt)*) => {};
 /// }
 /// ```
-#[cfg(integer128)]
+#[cfg(not(no_integer128))]
 #[macro_export]
 macro_rules! serde_if_integer128 {
     ($($tt:tt)*) => {
@@ -74,7 +74,7 @@ macro_rules! serde_if_integer128 {
     };
 }
 
-#[cfg(not(integer128))]
+#[cfg(no_integer128)]
 #[macro_export]
 #[doc(hidden)]
 macro_rules! serde_if_integer128 {

serde/src/lib.rs

@@ -31,8 +31,7 @@
 //! for Serde by the community.
 //!
 //! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.
-//! - [Bincode], a compact binary format
-//!   used for IPC within the Servo rendering engine.
+//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
 //! - [CBOR], a Concise Binary Object Representation designed for small message
 //!   size without the need for version negotiation.
 //! - [YAML], a self-proclaimed human-friendly configuration language that ain't
@@ -45,7 +44,6 @@
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
 //! - [JSON5], a superset of JSON including some productions from ES5.
-//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
 //! - [URL] query strings, in the x-www-form-urlencoded format.
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(deserialization only)*
@@ -59,22 +57,21 @@
 //!   and from DynamoDB.
 //!
 //! [JSON]: https://github.com/serde-rs/json
-//! [Bincode]: https://github.com/servo/bincode
+//! [Postcard]: https://github.com/jamesmunns/postcard
 //! [CBOR]: https://github.com/enarx/ciborium
 //! [YAML]: https://github.com/dtolnay/serde-yaml
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
-//! [TOML]: https://github.com/alexcrichton/toml-rs
+//! [TOML]: https://docs.rs/toml
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [RON]: https://github.com/ron-rs/ron
-//! [BSON]: https://github.com/zonyitoo/bson-rs
-//! [Avro]: https://github.com/flavray/avro-rs
+//! [BSON]: https://github.com/mongodb/bson-rust
+//! [Avro]: https://docs.rs/apache-avro
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
-//! [Postcard]: https://github.com/jamesmunns/postcard
 //! [URL]: https://docs.rs/serde_qs
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
+//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
 //! [S-expressions]: https://github.com/rotty/lexpr-rs
 //! [D-Bus]: https://docs.rs/zvariant
 //! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
@@ -84,7 +81,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.133")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.148")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and
@@ -103,10 +100,8 @@
         // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
         semicolon_if_nothing_returned,
         // not available in our oldest supported compiler
-        checked_conversions,
         empty_enum,
-        redundant_field_names,
-        redundant_static_lifetimes,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
         // integer and float ser/de requires these sorts of casts
         cast_possible_truncation,
         cast_possible_wrap,
@@ -120,9 +115,11 @@
         use_self,
         zero_prefixed_literal,
         // correctly used
+        derive_partial_eq_without_eq,
         enum_glob_use,
-        let_underscore_drop,
+        explicit_auto_deref,
         map_err_ignore,
+        new_without_default,
         result_unit_err,
         wildcard_imports,
         // not practical
@@ -227,30 +224,43 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::time::{SystemTime, UNIX_EPOCH};
 
-    #[cfg(all(feature = "std", collections_bound))]
+    #[cfg(all(feature = "std", not(no_collections_bound), no_ops_bound))]
     pub use std::collections::Bound;
 
-    #[cfg(core_reverse)]
+    #[cfg(not(no_core_reverse))]
     pub use self::core::cmp::Reverse;
 
-    #[cfg(ops_bound)]
+    #[cfg(not(no_ops_bound))]
     pub use self::core::ops::Bound;
 
-    #[cfg(range_inclusive)]
+    #[cfg(not(no_range_inclusive))]
     pub use self::core::ops::RangeInclusive;
 
-    #[cfg(all(feature = "std", std_atomic))]
+    #[cfg(all(feature = "std", not(no_std_atomic)))]
     pub use std::sync::atomic::{
         AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
         AtomicUsize, Ordering,
     };
-    #[cfg(all(feature = "std", std_atomic64))]
+    #[cfg(all(feature = "std", not(no_std_atomic64)))]
     pub use std::sync::atomic::{AtomicI64, AtomicU64};
 
-    #[cfg(any(core_duration, feature = "std"))]
+    #[cfg(any(feature = "std", not(no_core_duration)))]
     pub use self::core::time::Duration;
 }
 
+// None of this crate's error handling needs the `From::from` error conversion
+// performed implicitly by the `?` operator or the standard library's `try!`
+// macro. This simplified macro gives a 5.5% improvement in compile time
+// compared to standard `try!`, and 9% improvement compared to `?`.
+macro_rules! try {
+    ($expr:expr) => {
+        match $expr {
+            Ok(val) => val,
+            Err(err) => return Err(err),
+        }
+    };
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 #[macro_use]
@@ -296,7 +306,7 @@ extern crate serde_derive;
 #[doc(hidden)]
 pub use serde_derive::*;
 
-#[cfg(all(serde_derive, any(feature = "std", feature = "alloc")))]
+#[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
 mod actually_private {
     pub struct T;
 }

serde/src/private/de.rs

@@ -1262,6 +1262,17 @@ mod content {
         {
             match self.content {
                 Content::Unit => visitor.visit_unit(),
+
+                // Allow deserializing newtype variant containing unit.
+                //
+                //     #[derive(Deserialize)]
+                //     #[serde(tag = "result")]
+                //     enum Response<T> {
+                //         Success(T),
+                //     }
+                //
+                // We want {"result":"Success"} to deserialize into Response<()>.
+                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -1799,7 +1810,7 @@ mod content {
         V: Visitor<'de>,
         E: de::Error,
     {
-        let map = content.iter().map(|&(ref k, ref v)| {
+        let map = content.iter().map(|(k, v)| {
             (
                 ContentRefDeserializer::new(k),
                 ContentRefDeserializer::new(v),
@@ -2096,7 +2107,7 @@ mod content {
             let (variant, value) = match *self.content {
                 Content::Map(ref value) => {
                     let mut iter = value.iter();
-                    let &(ref variant, ref value) = match iter.next() {
+                    let (variant, value) = match iter.next() {
                         Some(v) => v,
                         None => {
                             return Err(de::Error::invalid_value(
@@ -2243,7 +2254,7 @@ mod content {
             V: de::Visitor<'de>,
         {
             match self.value {
-                Some(&Content::Seq(ref v)) => {
+                Some(Content::Seq(v)) => {
                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                 }
                 Some(other) => Err(de::Error::invalid_type(
@@ -2266,10 +2277,10 @@ mod content {
             V: de::Visitor<'de>,
         {
             match self.value {
-                Some(&Content::Map(ref v)) => {
+                Some(Content::Map(v)) => {
                     de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
                 }
-                Some(&Content::Seq(ref v)) => {
+                Some(Content::Seq(v)) => {
                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                 }
                 Some(other) => Err(de::Error::invalid_type(
@@ -2392,7 +2403,7 @@ mod content {
             T: de::DeserializeSeed<'de>,
         {
             match self.iter.next() {
-                Some(&(ref key, ref value)) => {
+                Some((key, value)) => {
                     self.value = Some(value);
                     seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
                 }

serde/src/private/mod.rs

@@ -1,6 +1,6 @@
-#[cfg(serde_derive)]
+#[cfg(not(no_serde_derive))]
 pub mod de;
-#[cfg(serde_derive)]
+#[cfg(not(no_serde_derive))]
 pub mod ser;
 
 pub mod size_hint;
@@ -22,7 +22,7 @@ pub use self::string::from_utf8_lossy;
 #[cfg(any(feature = "alloc", feature = "std"))]
 pub use lib::{ToString, Vec};
 
-#[cfg(core_try_from)]
+#[cfg(not(no_core_try_from))]
 pub use lib::convert::TryFrom;
 
 mod string {

serde/src/private/ser.rs

@@ -51,7 +51,6 @@ enum Unsupported {
     String,
     ByteArray,
     Optional,
-    Unit,
     #[cfg(any(feature = "std", feature = "alloc"))]
     UnitStruct,
     Sequence,
@@ -70,7 +69,6 @@ impl Display for Unsupported {
             Unsupported::String => formatter.write_str("a string"),
             Unsupported::ByteArray => formatter.write_str("a byte array"),
             Unsupported::Optional => formatter.write_str("an optional"),
-            Unsupported::Unit => formatter.write_str("unit"),
             #[cfg(any(feature = "std", feature = "alloc"))]
             Unsupported::UnitStruct => formatter.write_str("unit struct"),
             Unsupported::Sequence => formatter.write_str("a sequence"),
@@ -184,7 +182,9 @@ where
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Unit))
+        let mut map = try!(self.delegate.serialize_map(Some(1)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        map.end()
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
@@ -525,7 +525,7 @@ mod content {
                 Content::Map(ref entries) => {
                     use ser::SerializeMap;
                     let mut map = try!(serializer.serialize_map(Some(entries.len())));
-                    for &(ref k, ref v) in entries {
+                    for (k, v) in entries {
                         try!(map.serialize_entry(k, v));
                     }
                     map.end()

serde/src/ser/impls.rs

@@ -239,7 +239,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(range_inclusive)]
+#[cfg(not(no_range_inclusive))]
 impl<Idx> Serialize for RangeInclusive<Idx>
 where
     Idx: Serialize,
@@ -258,7 +258,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(ops_bound, collections_bound))]
+#[cfg(any(not(no_ops_bound), all(feature = "std", not(no_collections_bound))))]
 impl<T> Serialize for Bound<T>
 where
     T: Serialize,
@@ -467,7 +467,7 @@ where
 macro_rules! nonzero_integers {
     ( $( $T: ident, )+ ) => {
         $(
-            #[cfg(num_nonzero)]
+            #[cfg(not(no_num_nonzero))]
             impl Serialize for num::$T {
                 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                 where
@@ -488,7 +488,7 @@ nonzero_integers! {
     NonZeroUsize,
 }
 
-#[cfg(num_nonzero_signed)]
+#[cfg(not(no_num_nonzero_signed))]
 nonzero_integers! {
     NonZeroI8,
     NonZeroI16,
@@ -504,7 +504,7 @@ serde_if_integer128! {
         NonZeroU128,
     }
 
-    #[cfg(num_nonzero_signed)]
+    #[cfg(not(no_num_nonzero_signed))]
     nonzero_integers! {
         NonZeroI128,
     }
@@ -522,7 +522,7 @@ where
     }
 }
 
-impl<T> Serialize for RefCell<T>
+impl<T: ?Sized> Serialize for RefCell<T>
 where
     T: Serialize,
 {
@@ -538,7 +538,7 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<T> Serialize for Mutex<T>
+impl<T: ?Sized> Serialize for Mutex<T>
 where
     T: Serialize,
 {
@@ -554,7 +554,7 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<T> Serialize for RwLock<T>
+impl<T: ?Sized> Serialize for RwLock<T>
 where
     T: Serialize,
 {
@@ -591,7 +591,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(core_duration, feature = "std"))]
+#[cfg(any(feature = "std", not(no_core_duration)))]
 impl Serialize for Duration {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -614,9 +614,10 @@ impl Serialize for SystemTime {
         S: Serializer,
     {
         use super::SerializeStruct;
-        let duration_since_epoch = self
-            .duration_since(UNIX_EPOCH)
-            .map_err(|_| S::Error::custom("SystemTime must be later than UNIX_EPOCH"))?;
+        let duration_since_epoch = match self.duration_since(UNIX_EPOCH) {
+            Ok(duration_since_epoch) => duration_since_epoch,
+            Err(_) => return Err(S::Error::custom("SystemTime must be later than UNIX_EPOCH")),
+        };
         let mut state = try!(serializer.serialize_struct("SystemTime", 2));
         try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
         try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
@@ -735,8 +736,9 @@ impl Serialize for net::Ipv4Addr {
                 // Skip over delimiters that we initialized buf with
                 written += format_u8(*oct, &mut buf[written + 1..]) + 1;
             }
-            // We've only written ASCII bytes to the buffer, so it is valid UTF-8
-            serializer.serialize_str(unsafe { str::from_utf8_unchecked(&buf[..written]) })
+            // Safety: We've only written ASCII bytes to the buffer, so it is valid UTF-8
+            let buf = unsafe { str::from_utf8_unchecked(&buf[..written]) };
+            serializer.serialize_str(buf)
         } else {
             self.octets().serialize(serializer)
         }
@@ -890,7 +892,7 @@ where
     }
 }
 
-#[cfg(core_reverse)]
+#[cfg(not(no_core_reverse))]
 impl<T> Serialize for Reverse<T>
 where
     T: Serialize,
@@ -906,7 +908,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
     ($($ty:ident)*) => {
         $(
@@ -916,21 +918,21 @@ macro_rules! atomic_impl {
                     S: Serializer,
                 {
                     // Matches the atomic ordering used in libcore for the Debug impl
-                    self.load(Ordering::SeqCst).serialize(serializer)
+                    self.load(Ordering::Relaxed).serialize(serializer)
                 }
             }
         )*
     }
 }
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 atomic_impl! {
     AtomicBool
     AtomicI8 AtomicI16 AtomicI32 AtomicIsize
     AtomicU8 AtomicU16 AtomicU32 AtomicUsize
 }
 
-#[cfg(all(feature = "std", std_atomic64))]
+#[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
     AtomicI64 AtomicU64
 }

serde/src/ser/mod.rs

@@ -30,7 +30,7 @@
 //! # The Serializer trait
 //!
 //! [`Serializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
+//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
 //!
 //! A partial list of well-maintained formats is given on the [Serde
 //! website][data formats].
@@ -99,7 +99,7 @@
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
 //! [`Serialize`]: ../trait.Serialize.html
 //! [`Serializer`]: ../trait.Serializer.html
-//! [`bincode`]: https://github.com/servo/bincode
+//! [`postcard`]: https://github.com/jamesmunns/postcard
 //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
@@ -314,7 +314,7 @@ pub trait Serialize {
 ///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
 ///
 /// Many Serde serializers produce text or binary data as output, for example
-/// JSON or Bincode. This is not a requirement of the `Serializer` trait, and
+/// JSON or Postcard. This is not a requirement of the `Serializer` trait, and
 /// there are serializers that do not produce text or binary output. One example
 /// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
 /// serializer) that produces a `serde_json::Value` data structure in memory as
@@ -1280,13 +1280,13 @@ pub trait Serializer: Sized {
         let iter = iter.into_iter();
         let mut serializer = try!(self.serialize_seq(iterator_len_hint(&iter)));
 
-        #[cfg(iterator_try_fold)]
+        #[cfg(not(no_iterator_try_fold))]
         {
             let mut iter = iter;
             try!(iter.try_for_each(|item| serializer.serialize_element(&item)));
         }
 
-        #[cfg(not(iterator_try_fold))]
+        #[cfg(no_iterator_try_fold)]
         {
             for item in iter {
                 try!(serializer.serialize_element(&item));
@@ -1331,13 +1331,13 @@ pub trait Serializer: Sized {
         let iter = iter.into_iter();
         let mut serializer = try!(self.serialize_map(iterator_len_hint(&iter)));
 
-        #[cfg(iterator_try_fold)]
+        #[cfg(not(no_iterator_try_fold))]
         {
             let mut iter = iter;
             try!(iter.try_for_each(|(key, value)| serializer.serialize_entry(&key, &value)));
         }
 
-        #[cfg(not(iterator_try_fold))]
+        #[cfg(no_iterator_try_fold)]
         {
             for (key, value) in iter {
                 try!(serializer.serialize_entry(&key, &value));
@@ -1423,7 +1423,7 @@ pub trait Serializer: Sized {
     /// Some types have a human-readable form that may be somewhat expensive to
     /// construct, as well as a binary form that is compact and efficient.
     /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Bincode will prefer the
+    /// human-readable one and binary formats like Postcard will prefer the
     /// compact one.
     ///
     /// ```edition2018

serde_derive/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.31.0"

serde_derive/Cargo.toml

@@ -1,16 +1,17 @@
 [package]
 name = "serde_derive"
-version = "1.0.133" # remember to update html_root_url
+version = "1.0.148" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.31"
-license = "MIT OR Apache-2.0"
+categories = ["no-std"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
 documentation = "https://serde.rs/derive.html"
-keywords = ["serde", "serialization", "no_std"]
-readme = "crates-io.md"
+homepage = "https://serde.rs"
 include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization", "no_std", "derive"]
+license = "MIT OR Apache-2.0"
+readme = "crates-io.md"
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.31"
 
 [features]
 default = []
@@ -23,7 +24,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = "1.0.60"
+syn = "1.0.104"
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/build.rs

@@ -13,14 +13,14 @@ fn main() {
 
     // Underscore const names stabilized in Rust 1.37:
     // https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html#using-unnamed-const-items-for-macros
-    if minor >= 37 {
-        println!("cargo:rustc-cfg=underscore_consts");
+    if minor < 37 {
+        println!("cargo:rustc-cfg=no_underscore_consts");
     }
 
     // The ptr::addr_of! macro stabilized in Rust 1.51:
     // https://blog.rust-lang.org/2021/03/25/Rust-1.51.0.html#stabilized-apis
-    if minor >= 51 {
-        println!("cargo:rustc-cfg=ptr_addr_of");
+    if minor < 51 {
+        println!("cargo:rustc-cfg=no_ptr_addr_of");
     }
 }
 

serde_derive/src/bound.rs

@@ -184,9 +184,7 @@ pub fn with_bound(
 
                 syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
 
-                #[cfg(test)]
-                syn::Type::__TestExhaustive(_) => unimplemented!(),
-                #[cfg(not(test))]
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                 _ => {}
             }
         }

serde_derive/src/de.rs

@@ -10,6 +10,7 @@ use fragment::{Expr, Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
 use pretend;
+use this;
 
 use std::collections::BTreeSet;
 use std::ptr;
@@ -111,9 +112,13 @@ struct Parameters {
     local: syn::Ident,
 
     /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
+    /// types (does not include generic parameters) or `some::remote::Path` for
+    /// remote types.
+    this_type: syn::Path,
+
+    /// Same as `this_type` but using `::<T>` for generic parameters for use in
+    /// expression position.
+    this_value: syn::Path,
 
     /// Generics including any explicit and inferred bounds for the impl.
     generics: syn::Generics,
@@ -133,10 +138,8 @@ struct Parameters {
 impl Parameters {
     fn new(cont: &Container) -> Self {
         let local = cont.ident.clone();
-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
+        let this_type = this::this_type(cont);
+        let this_value = this::this_value(cont);
         let borrowed = borrowed_lifetimes(cont);
         let generics = build_generics(cont, &borrowed);
         let has_getter = cont.data.has_getter();
@@ -144,7 +147,8 @@ impl Parameters {
 
         Parameters {
             local,
-            this,
+            this_type,
+            this_value,
             generics,
             borrowed,
             has_getter,
@@ -155,7 +159,7 @@ impl Parameters {
     /// Type name to use in error messages and `&'static str` arguments to
     /// various Deserializer methods.
     fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
+        self.this_type.segments.last().unwrap().ident.to_string()
     }
 }
 
@@ -358,7 +362,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
         Data::Enum(_) => unreachable!(),
     };
 
-    let this = &params.this;
+    let this_value = &params.this_value;
     let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
 
     let path = match transparent_field.attrs.deserialize_with() {
@@ -386,7 +390,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
     quote_block! {
         _serde::__private::Result::map(
             #path(__deserializer),
-            |__transparent| #this { #(#assign),* })
+            |__transparent| #this_value { #(#assign),* })
     }
 }
 
@@ -407,7 +411,8 @@ fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
 }
 
 fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let type_name = cattrs.name().deserialize_name();
 
     let expecting = format!("unit struct {}", params.type_name());
@@ -417,7 +422,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
         struct __Visitor;
 
         impl<'de> _serde::de::Visitor<'de> for __Visitor {
-            type Value = #this;
+            type Value = #this_type;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -428,7 +433,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::Ok(#this)
+                _serde::__private::Ok(#this_value)
             }
         }
 
@@ -443,7 +448,8 @@ fn deserialize_tuple(
     cattrs: &attr::Container,
     deserializer: Option<TokenStream>,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -457,7 +463,7 @@ fn deserialize_tuple(
         let local = &params.local;
         quote!(#local)
     } else {
-        quote!(#this)
+        quote!(#this_value)
     };
 
     let is_enum = variant_ident.is_some();
@@ -485,7 +491,7 @@ fn deserialize_tuple(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData,
         }
     };
@@ -510,12 +516,12 @@ fn deserialize_tuple(
 
     quote_block! {
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -544,7 +550,7 @@ fn deserialize_tuple_in_place(
     cattrs: &attr::Container,
     deserializer: Option<TokenStream>,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -600,7 +606,7 @@ fn deserialize_tuple_in_place(
 
     quote_block! {
         struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this #ty_generics,
+            place: &#place_life mut #this_type #ty_generics,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
@@ -705,9 +711,10 @@ fn deserialize_seq(
     };
 
     if params.has_getter {
-        let this = &params.this;
+        let this_type = &params.this_type;
+        let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -801,14 +808,14 @@ fn deserialize_seq_in_place(
         }
     });
 
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (_, ty_generics, _) = params.generics.split_for_impl();
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics  = _serde::__private::Default::default();
+            let __default: #this_type #ty_generics = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
-            let __default: #this #ty_generics  = #path();
+            let __default: #this_type #ty_generics = #path();
         )),
         attr::Default::None => {
             // We don't need the default value, to prevent an unused variable warning
@@ -849,9 +856,10 @@ fn deserialize_newtype_struct(
 
     let mut result = quote!(#type_path(__field0));
     if params.has_getter {
-        let this = &params.this;
+        let this_type = &params.this_type;
+        let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -901,7 +909,8 @@ fn deserialize_struct(
 ) -> Fragment {
     let is_enum = variant_ident.is_some();
 
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -913,7 +922,7 @@ fn deserialize_struct(
         let local = &params.local;
         quote!(#local)
     } else {
-        quote!(#this)
+        quote!(#this_value)
     };
 
     let type_path = match variant_ident {
@@ -941,7 +950,7 @@ fn deserialize_struct(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData,
         }
     };
@@ -993,7 +1002,7 @@ fn deserialize_struct(
     let visitor_seed = if is_enum && cattrs.has_flatten() {
         Some(quote! {
             impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
-                type Value = #this #ty_generics;
+                type Value = #this_type #ty_generics;
 
                 fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
                 where
@@ -1011,12 +1020,12 @@ fn deserialize_struct(
         #field_visitor
 
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1057,7 +1066,7 @@ fn deserialize_struct_in_place(
         return None;
     }
 
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -1123,7 +1132,7 @@ fn deserialize_struct_in_place(
         #field_visitor
 
         struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this #ty_generics,
+            place: &#place_life mut #this_type #ty_generics,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
@@ -1212,7 +1221,7 @@ fn deserialize_externally_tagged_enum(
     variants: &[Variant],
     cattrs: &attr::Container,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -1266,12 +1275,12 @@ fn deserialize_externally_tagged_enum(
         #variant_visitor
 
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1292,7 +1301,7 @@ fn deserialize_externally_tagged_enum(
             #type_name,
             VARIANTS,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this #ty_generics>,
+                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
                 lifetime: _serde::__private::PhantomData,
             },
         )
@@ -1354,7 +1363,8 @@ fn deserialize_adjacently_tagged_enum(
     tag: &str,
     content: &str,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -1415,13 +1425,13 @@ fn deserialize_adjacently_tagged_enum(
 
             let arm = match variant.style {
                 Style::Unit => quote! {
-                    _serde::__private::Ok(#this::#variant_ident)
+                    _serde::__private::Ok(#this_value::#variant_ident)
                 },
                 Style::Newtype if variant.attrs.deserialize_with().is_none() => {
                     let span = variant.original.span();
                     let func = quote_spanned!(span=> _serde::__private::de::missing_field);
                     quote! {
-                        #func(#content).map(#this::#variant_ident)
+                        #func(#content).map(#this_value::#variant_ident)
                     }
                 }
                 _ => {
@@ -1513,12 +1523,12 @@ fn deserialize_adjacently_tagged_enum(
 
         struct __Seed #de_impl_generics #where_clause {
             field: __Field,
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
             where
@@ -1531,12 +1541,12 @@ fn deserialize_adjacently_tagged_enum(
         }
 
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1638,7 +1648,7 @@ fn deserialize_adjacently_tagged_enum(
             #type_name,
             FIELDS,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this #ty_generics>,
+                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
                 lifetime: _serde::__private::PhantomData,
             },
         )
@@ -1707,10 +1717,10 @@ fn deserialize_externally_tagged_variant(
 
     match variant.style {
         Style::Unit => {
-            let this = &params.this;
+            let this_value = &params.this_value;
             quote_block! {
                 try!(_serde::de::VariantAccess::unit_variant(__variant));
-                _serde::__private::Ok(#this::#variant_ident)
+                _serde::__private::Ok(#this_value::#variant_ident)
             }
         }
         Style::Newtype => deserialize_externally_tagged_newtype_variant(
@@ -1749,7 +1759,7 @@ fn deserialize_internally_tagged_variant(
 
     match effective_style(variant) {
         Style::Unit => {
-            let this = &params.this;
+            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| {
@@ -1758,7 +1768,7 @@ fn deserialize_internally_tagged_variant(
             });
             quote_block! {
                 try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
-                _serde::__private::Ok(#this::#variant_ident #default)
+                _serde::__private::Ok(#this_value::#variant_ident #default)
             }
         }
         Style::Newtype => deserialize_untagged_newtype_variant(
@@ -1796,7 +1806,7 @@ fn deserialize_untagged_variant(
 
     match effective_style(variant) {
         Style::Unit => {
-            let this = &params.this;
+            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| {
@@ -1808,7 +1818,7 @@ fn deserialize_untagged_variant(
                     #deserializer,
                     _serde::__private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
                 ) {
-                    _serde::__private::Ok(()) => _serde::__private::Ok(#this::#variant_ident #default),
+                    _serde::__private::Ok(()) => _serde::__private::Ok(#this_value::#variant_ident #default),
                     _serde::__private::Err(__err) => _serde::__private::Err(__err),
                 }
             }
@@ -1843,14 +1853,13 @@ fn deserialize_externally_tagged_newtype_variant(
     field: &Field,
     cattrs: &attr::Container,
 ) -> Fragment {
-    let this = &params.this;
+    let this_value = &params.this_value;
 
     if field.attrs.skip_deserializing() {
-        let this = &params.this;
         let default = Expr(expr_is_missing(field, cattrs));
         return quote_block! {
             try!(_serde::de::VariantAccess::unit_variant(__variant));
-            _serde::__private::Ok(#this::#variant_ident(#default))
+            _serde::__private::Ok(#this_value::#variant_ident(#default))
         };
     }
 
@@ -1861,7 +1870,7 @@ fn deserialize_externally_tagged_newtype_variant(
             let func =
                 quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
             quote_expr! {
-                _serde::__private::Result::map(#func(__variant), #this::#variant_ident)
+                _serde::__private::Result::map(#func(__variant), #this_value::#variant_ident)
             }
         }
         Some(path) => {
@@ -1870,7 +1879,7 @@ fn deserialize_externally_tagged_newtype_variant(
                 #wrapper
                 _serde::__private::Result::map(
                     _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
-                    |__wrapper| #this::#variant_ident(__wrapper.value))
+                    |__wrapper| #this_value::#variant_ident(__wrapper.value))
             }
         }
     }
@@ -1882,20 +1891,20 @@ fn deserialize_untagged_newtype_variant(
     field: &Field,
     deserializer: &TokenStream,
 ) -> Fragment {
-    let this = &params.this;
+    let this_value = &params.this_value;
     let field_ty = field.ty;
     match field.attrs.deserialize_with() {
         None => {
             let span = field.original.span();
             let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote_expr! {
-                _serde::__private::Result::map(#func(#deserializer), #this::#variant_ident)
+                _serde::__private::Result::map(#func(#deserializer), #this_value::#variant_ident)
             }
         }
         Some(path) => {
             quote_block! {
                 let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
-                _serde::__private::Result::map(__value, #this::#variant_ident)
+                _serde::__private::Result::map(__value, #this_value::#variant_ident)
             }
         }
     }
@@ -1907,7 +1916,7 @@ fn deserialize_generated_identifier(
     is_variant: bool,
     other_idx: Option<usize>,
 ) -> Fragment {
-    let this = quote!(__Field);
+    let this_value = quote!(__Field);
     let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
 
     let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
@@ -1927,7 +1936,7 @@ fn deserialize_generated_identifier(
     };
 
     let visitor_impl = Stmts(deserialize_identifier(
-        &this,
+        &this_value,
         fields,
         is_variant,
         fallthrough,
@@ -1982,8 +1991,8 @@ fn deserialize_custom_identifier(
         attr::Identifier::No => unreachable!(),
     };
 
-    let this = &params.this;
-    let this = quote!(#this);
+    let this_type = params.this_type.to_token_stream();
+    let this_value = params.this_value.to_token_stream();
 
     let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
         let last_ident = &last.ident;
@@ -1992,7 +2001,7 @@ fn deserialize_custom_identifier(
             // last variant (checked in `check_identifier`), so all preceding
             // are ordinary variants.
             let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident));
+            let fallthrough = quote!(_serde::__private::Ok(#this_value::#last_ident));
             (ordinary, Some(fallthrough), None)
         } else if let Style::Newtype = last.style {
             let ordinary = &variants[..variants.len() - 1];
@@ -2002,7 +2011,7 @@ fn deserialize_custom_identifier(
                         _serde::Deserialize::deserialize(
                             _serde::__private::de::IdentifierDeserializer::from(#value)
                         ),
-                        #this::#last_ident)
+                        #this_value::#last_ident)
                 }
             };
             (
@@ -2050,7 +2059,7 @@ fn deserialize_custom_identifier(
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
     let visitor_impl = Stmts(deserialize_identifier(
-        &this,
+        &this_value,
         &names_idents,
         is_variant,
         fallthrough,
@@ -2063,18 +2072,18 @@ fn deserialize_custom_identifier(
         #names_const
 
         struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             #visitor_impl
         }
 
         let __visitor = __FieldVisitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData,
         };
         _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
@@ -2082,7 +2091,7 @@ fn deserialize_custom_identifier(
 }
 
 fn deserialize_identifier(
-    this: &TokenStream,
+    this_value: &TokenStream,
     fields: &[(String, Ident, Vec<String>)],
     is_variant: bool,
     fallthrough: Option<TokenStream>,
@@ -2103,11 +2112,11 @@ fn deserialize_identifier(
 
     let constructors: &Vec<_> = &flat_fields
         .iter()
-        .map(|(_, ident)| quote!(#this::#ident))
+        .map(|(_, ident)| quote!(#this_value::#ident))
         .collect();
     let main_constructors: &Vec<_> = &fields
         .iter()
-        .map(|(_, ident, _)| quote!(#this::#ident))
+        .map(|(_, ident, _)| quote!(#this_value::#ident))
         .collect();
 
     let expecting = expecting.unwrap_or(if is_variant {
@@ -2621,9 +2630,10 @@ fn deserialize_map(
 
     let mut result = quote!(#struct_path { #(#result),* });
     if params.has_getter {
-        let this = &params.this;
+        let this_type = &params.this_type;
+        let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -2803,15 +2813,15 @@ fn deserialize_map_in_place(
             }
         });
 
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (_, _, ty_generics, _) = split_with_de_lifetime(params);
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics = _serde::__private::Default::default();
+            let __default: #this_type #ty_generics = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
-            let __default: #this #ty_generics = #path();
+            let __default: #this_type #ty_generics = #path();
         )),
         attr::Default::None => {
             // We don't need the default value, to prevent an unused variable warning
@@ -2844,7 +2854,7 @@ fn wrap_deserialize_with(
     value_ty: &TokenStream,
     deserialize_with: &syn::ExprPath,
 ) -> (TokenStream, TokenStream) {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -2852,7 +2862,7 @@ fn wrap_deserialize_with(
     let wrapper = quote! {
         struct __DeserializeWith #de_impl_generics #where_clause {
             value: #value_ty,
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
@@ -2903,7 +2913,7 @@ fn unwrap_to_variant_closure(
     variant: &Variant,
     with_wrapper: bool,
 ) -> TokenStream {
-    let this = &params.this;
+    let this_value = &params.this_value;
     let variant_ident = &variant.ident;
 
     let (arg, wrapper) = if with_wrapper {
@@ -2924,23 +2934,23 @@ fn unwrap_to_variant_closure(
         Style::Struct if variant.fields.len() == 1 => {
             let member = &variant.fields[0].member;
             quote! {
-                |#arg| #this::#variant_ident { #member: #wrapper }
+                |#arg| #this_value::#variant_ident { #member: #wrapper }
             }
         }
         Style::Struct => {
             let members = variant.fields.iter().map(|field| &field.member);
             quote! {
-                |#arg| #this::#variant_ident { #(#members: #wrapper.#field_access),* }
+                |#arg| #this_value::#variant_ident { #(#members: #wrapper.#field_access),* }
             }
         }
         Style::Tuple => quote! {
-            |#arg| #this::#variant_ident(#(#wrapper.#field_access),*)
+            |#arg| #this_value::#variant_ident(#(#wrapper.#field_access),*)
         },
         Style::Newtype => quote! {
-            |#arg| #this::#variant_ident(#wrapper)
+            |#arg| #this_value::#variant_ident(#wrapper)
         },
         Style::Unit => quote! {
-            |#arg| #this::#variant_ident
+            |#arg| #this_value::#variant_ident
         },
     }
 }

serde_derive/src/dummy.rs

@@ -12,10 +12,10 @@ pub fn wrap_in_const(
 ) -> TokenStream {
     let try_replacement = try::replacement();
 
-    let dummy_const = if cfg!(underscore_consts) {
-        format_ident!("_")
-    } else {
+    let dummy_const = if cfg!(no_underscore_consts) {
         format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
+    } else {
+        format_ident!("_")
     };
 
     let use_serde = match serde_path {

serde_derive/src/internals/attr.rs

@@ -1912,9 +1912,7 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
         | syn::Type::Infer(_)
         | syn::Type::Verbatim(_) => {}
 
-        #[cfg(test)]
-        syn::Type::__TestExhaustive(_) => unimplemented!(),
-        #[cfg(not(test))]
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
         _ => {}
     }
 }

serde_derive/src/internals/check.rs

@@ -6,6 +6,7 @@ use syn::{Member, Type};
 /// Cross-cutting checks that require looking at more than a single attrs
 /// object. Simpler checks should happen when parsing and building the attrs.
 pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
+    check_remote_generic(cx, cont);
     check_getter(cx, cont);
     check_flatten(cx, cont);
     check_identifier(cx, cont);
@@ -16,6 +17,28 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     check_from_and_try_from(cx, cont);
 }
 
+/// Remote derive definition type must have either all of the generics of the
+/// remote type:
+///
+///     #[serde(remote = "Generic")]
+///     struct Generic<T> {…}
+///
+/// or none of them, i.e. defining impls for one concrete instantiation of the
+/// remote type only:
+///
+///     #[serde(remote = "Generic<T>")]
+///     struct ConcreteDef {…}
+///
+fn check_remote_generic(cx: &Ctxt, cont: &Container) {
+    if let Some(remote) = cont.attrs.remote() {
+        let local_has_generic = !cont.generics.params.is_empty();
+        let remote_has_generic = !remote.segments.last().unwrap().arguments.is_none();
+        if local_has_generic && remote_has_generic {
+            cx.error_spanned_by(remote, "remove generic parameters from this path");
+        }
+    }
+}
+
 /// Getters are only allowed inside structs (not enums) with the `remote`
 /// attribute.
 fn check_getter(cx: &Ctxt, cont: &Container) {

serde_derive/src/internals/receiver.rs

@@ -147,9 +147,7 @@ impl ReplaceReceiver<'_> {
 
             Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
 
-            #[cfg(test)]
-            Type::__TestExhaustive(_) => unimplemented!(),
-            #[cfg(not(test))]
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
             _ => {}
         }
     }

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.133")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.148")]
 #![allow(unknown_lints, bare_trait_objects)]
 // Ignored clippy lints
 #![allow(
@@ -22,6 +22,7 @@
     clippy::cognitive_complexity,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
     clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
     clippy::enum_variant_names,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
     clippy::manual_map,
@@ -42,7 +43,6 @@
     clippy::enum_glob_use,
     clippy::indexing_slicing,
     clippy::items_after_statements,
-    clippy::let_underscore_drop,
     clippy::manual_assert,
     clippy::map_err_ignore,
     clippy::match_same_arms,
@@ -60,6 +60,7 @@
     clippy::use_self,
     clippy::wildcard_imports
 )]
+#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]
 
 #[macro_use]
 extern crate quote;
@@ -83,6 +84,7 @@ mod de;
 mod dummy;
 mod pretend;
 mod ser;
+mod this;
 mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]

serde_derive/src/pretend.rs

@@ -97,7 +97,7 @@ fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> Toke
 
     let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();
 
-    #[cfg(ptr_addr_of)]
+    #[cfg(not(no_ptr_addr_of))]
     {
         quote! {
             match _serde::__private::None::<&#type_ident #ty_generics> {
@@ -111,7 +111,7 @@ fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> Toke
         }
     }
 
-    #[cfg(not(ptr_addr_of))]
+    #[cfg(no_ptr_addr_of)]
     {
         let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
 

serde_derive/src/ser.rs

@@ -8,6 +8,7 @@ use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, replace_receiver, Ctxt, Derive};
 use pretend;
+use this;
 
 pub fn expand_derive_serialize(
     input: &mut syn::DeriveInput,
@@ -82,9 +83,13 @@ struct Parameters {
     self_var: Ident,
 
     /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
+    /// types (does not include generic parameters) or `some::remote::Path` for
+    /// remote types.
+    this_type: syn::Path,
+
+    /// Same as `this_type` but using `::<T>` for generic parameters for use in
+    /// expression position.
+    this_value: syn::Path,
 
     /// Generics including any explicit and inferred bounds for the impl.
     generics: syn::Generics,
@@ -105,18 +110,15 @@ impl Parameters {
             Ident::new("self", Span::call_site())
         };
 
-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
-
+        let this_type = this::this_type(cont);
+        let this_value = this::this_value(cont);
         let is_packed = cont.attrs.is_packed();
-
         let generics = build_generics(cont);
 
         Parameters {
             self_var,
-            this,
+            this_type,
+            this_value,
             generics,
             is_remote,
             is_packed,
@@ -126,7 +128,7 @@ impl Parameters {
     /// Type name to use in error messages and `&'static str` arguments to
     /// various Serializer methods.
     fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
+        self.this_type.segments.last().unwrap().ident.to_string()
     }
 }
 
@@ -427,7 +429,7 @@ fn serialize_variant(
     variant_index: u32,
     cattrs: &attr::Container,
 ) -> TokenStream {
-    let this = &params.this;
+    let this_value = &params.this_value;
     let variant_ident = &variant.ident;
 
     if variant.attrs.skip_serializing() {
@@ -445,32 +447,32 @@ fn serialize_variant(
             Style::Struct => quote!({ .. }),
         };
         quote! {
-            #this::#variant_ident #fields_pat => #skipped_err,
+            #this_value::#variant_ident #fields_pat => #skipped_err,
         }
     } else {
         // variant wasn't skipped
         let case = match variant.style {
             Style::Unit => {
                 quote! {
-                    #this::#variant_ident
+                    #this_value::#variant_ident
                 }
             }
             Style::Newtype => {
                 quote! {
-                    #this::#variant_ident(ref __field0)
+                    #this_value::#variant_ident(ref __field0)
                 }
             }
             Style::Tuple => {
                 let field_names = (0..variant.fields.len())
                     .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                 quote! {
-                    #this::#variant_ident(#(ref #field_names),*)
+                    #this_value::#variant_ident(#(ref #field_names),*)
                 }
             }
             Style::Struct => {
                 let members = variant.fields.iter().map(|f| &f.member);
                 quote! {
-                    #this::#variant_ident { #(ref #members),* }
+                    #this_value::#variant_ident { #(ref #members),* }
                 }
             }
         };
@@ -640,7 +642,7 @@ fn serialize_adjacently_tagged_variant(
     tag: &str,
     content: &str,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let type_name = cattrs.name().serialize_name();
     let variant_name = variant.attrs.name().serialize_name();
 
@@ -719,7 +721,7 @@ fn serialize_adjacently_tagged_variant(
     quote_block! {
         struct __AdjacentlyTagged #wrapper_generics #where_clause {
             data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
@@ -741,7 +743,7 @@ fn serialize_adjacently_tagged_variant(
         try!(_serde::ser::SerializeStruct::serialize_field(
             &mut __struct, #content, &__AdjacentlyTagged {
                 data: (#(#fields_ident,)*),
-                phantom: _serde::__private::PhantomData::<#this #ty_generics>,
+                phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
             }));
         _serde::ser::SerializeStruct::end(__struct)
     }
@@ -866,8 +868,8 @@ enum StructVariant<'a> {
     Untagged,
 }
 
-fn serialize_struct_variant<'a>(
-    context: StructVariant<'a>,
+fn serialize_struct_variant(
+    context: StructVariant,
     params: &Parameters,
     fields: &[Field],
     name: &str,
@@ -950,8 +952,8 @@ fn serialize_struct_variant<'a>(
     }
 }
 
-fn serialize_struct_variant_with_flatten<'a>(
-    context: StructVariant<'a>,
+fn serialize_struct_variant_with_flatten(
+    context: StructVariant,
     params: &Parameters,
     fields: &[Field],
     name: &str,
@@ -971,7 +973,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             variant_index,
             variant_name,
         } => {
-            let this = &params.this;
+            let this_type = &params.this_type;
             let fields_ty = fields.iter().map(|f| &f.ty);
             let members = &fields.iter().map(|f| &f.member).collect::<Vec<_>>();
 
@@ -982,7 +984,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 struct __EnumFlatten #wrapper_generics #where_clause {
                     data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::__private::PhantomData<#this #ty_generics>,
+                    phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
                 }
 
                 impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
@@ -1006,7 +1008,7 @@ fn serialize_struct_variant_with_flatten<'a>(
                     #variant_name,
                     &__EnumFlatten {
                         data: (#(#members,)*),
-                        phantom: _serde::__private::PhantomData::<#this #ty_generics>,
+                        phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
                     })
             }
         }
@@ -1192,7 +1194,7 @@ fn wrap_serialize_with(
     field_tys: &[&syn::Type],
     field_exprs: &[TokenStream],
 ) -> TokenStream {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (_, ty_generics, where_clause) = params.generics.split_for_impl();
 
     let wrapper_generics = if field_exprs.is_empty() {
@@ -1212,7 +1214,7 @@ fn wrap_serialize_with(
     quote!({
         struct __SerializeWith #wrapper_impl_generics #where_clause {
             values: (#(&'__a #field_tys, )*),
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
@@ -1226,7 +1228,7 @@ fn wrap_serialize_with(
 
         &__SerializeWith {
             values: (#(#field_exprs, )*),
-            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
         }
     })
 }

serde_derive/src/this.rs

@@ -0,0 +1,32 @@
+use internals::ast::Container;
+use syn::{Path, PathArguments, Token};
+
+pub fn this_type(cont: &Container) -> Path {
+    if let Some(remote) = cont.attrs.remote() {
+        let mut this = remote.clone();
+        for segment in &mut this.segments {
+            if let PathArguments::AngleBracketed(arguments) = &mut segment.arguments {
+                arguments.colon2_token = None;
+            }
+        }
+        this
+    } else {
+        Path::from(cont.ident.clone())
+    }
+}
+
+pub fn this_value(cont: &Container) -> Path {
+    if let Some(remote) = cont.attrs.remote() {
+        let mut this = remote.clone();
+        for segment in &mut this.segments {
+            if let PathArguments::AngleBracketed(arguments) = &mut segment.arguments {
+                if arguments.colon2_token.is_none() {
+                    arguments.colon2_token = Some(Token![::](arguments.lt_token.span));
+                }
+            }
+        }
+        this
+    } else {
+        Path::from(cont.ident.clone())
+    }
+}

serde_derive_internals/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.31.0"

serde_derive_internals/Cargo.toml

@@ -2,14 +2,14 @@
 name = "serde_derive_internals"
 version = "0.26.0" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.31"
-license = "MIT OR Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.rs/serde_derive_internals"
-keywords = ["serde", "serialization"]
+homepage = "https://serde.rs"
 include = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.31"
 
 [lib]
 path = "lib.rs"
@@ -17,7 +17,7 @@ path = "lib.rs"
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.60", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+syn = { version = "1.0.104", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/lib.rs

@@ -5,6 +5,7 @@
     clippy::cognitive_complexity,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
     clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
     clippy::manual_map,
     clippy::missing_panics_doc,
@@ -21,7 +22,6 @@
     clippy::doc_markdown,
     clippy::enum_glob_use,
     clippy::items_after_statements,
-    clippy::let_underscore_drop,
     clippy::manual_assert,
     clippy::match_same_arms,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984

serde_test/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.13.0"

serde_test/Cargo.toml

@@ -1,16 +1,18 @@
 [package]
 name = "serde_test"
-version = "1.0.133" # remember to update html_root_url
+version = "1.0.148" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.15"
-license = "MIT OR Apache-2.0"
+build = "build.rs"
+categories = ["development-tools::testing"]
 description = "Token De/Serializer for testing De/Serialize implementations"
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_test/"
-keywords = ["serde", "serialization"]
+homepage = "https://serde.rs"
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization", "testing", "dev-dependencies"]
+license = "MIT OR Apache-2.0"
 readme = "crates-io.md"
-include = ["src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.13"
 
 [dependencies]
 serde = { version = "1.0.60", path = "../serde" }

serde_test/build.rs

@@ -1,6 +1,6 @@
 use std::env;
 use std::process::Command;
-use std::str;
+use std::str::{self, FromStr};
 
 // The rustc-cfg strings below are *not* public API. Please let us know by
 // opening a GitHub issue if your build environment requires some way to enable
@@ -13,18 +13,36 @@ fn main() {
 
     // #[track_caller] stabilized in Rust 1.46:
     // https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html#track_caller
-    if minor >= 46 {
-        println!("cargo:rustc-cfg=track_caller");
+    if minor < 46 {
+        println!("cargo:rustc-cfg=no_track_caller");
     }
 }
 
 fn rustc_minor_version() -> Option<u32> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
+    let rustc = match env::var_os("RUSTC") {
+        Some(rustc) => rustc,
+        None => return None,
+    };
+
+    let output = match Command::new(rustc).arg("--version").output() {
+        Ok(output) => output,
+        Err(_) => return None,
+    };
+
+    let version = match str::from_utf8(&output.stdout) {
+        Ok(version) => version,
+        Err(_) => return None,
+    };
+
     let mut pieces = version.split('.');
     if pieces.next() != Some("rustc 1") {
         return None;
     }
-    pieces.next()?.parse().ok()
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    u32::from_str(next).ok()
 }

serde_test/src/assert.rs

@@ -28,7 +28,7 @@ use std::fmt::Debug;
 ///     Token::StructEnd,
 /// ]);
 /// ```
-#[cfg_attr(track_caller, track_caller)]
+#[cfg_attr(not(no_track_caller), track_caller)]
 pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Serialize + Deserialize<'de> + PartialEq + Debug,
@@ -59,8 +59,8 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
-#[cfg_attr(track_caller, track_caller)]
-pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
+#[cfg_attr(not(no_track_caller), track_caller)]
+pub fn assert_ser_tokens<T: ?Sized>(value: &T, tokens: &[Token])
 where
     T: Serialize,
 {
@@ -112,8 +112,8 @@ where
 ///     assert_ser_tokens_error(&example, expected, error);
 /// }
 /// ```
-#[cfg_attr(track_caller, track_caller)]
-pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: &str)
+#[cfg_attr(not(no_track_caller), track_caller)]
+pub fn assert_ser_tokens_error<T: ?Sized>(value: &T, tokens: &[Token], error: &str)
 where
     T: Serialize,
 {
@@ -150,7 +150,7 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
-#[cfg_attr(track_caller, track_caller)]
+#[cfg_attr(not(no_track_caller), track_caller)]
 pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Deserialize<'de> + PartialEq + Debug,
@@ -203,7 +203,7 @@ where
 ///     "unknown field `x`, expected `a` or `b`",
 /// );
 /// ```
-#[cfg_attr(track_caller, track_caller)]
+#[cfg_attr(not(no_track_caller), track_caller)]
 pub fn assert_de_tokens_error<'de, T>(tokens: &'de [Token], error: &str)
 where
     T: Deserialize<'de>,

serde_test/src/lib.rs

@@ -144,7 +144,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.133")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.148")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
@@ -153,6 +153,7 @@
     feature = "cargo-clippy",
     allow(
         cloned_instead_of_copied,
+        doc_link_with_quotes, // https://github.com/rust-lang/rust-clippy/issues/8961
         empty_line_after_outer_attr,
         manual_assert,
         missing_docs_in_private_items,
@@ -161,6 +162,7 @@
         must_use_candidate,
         redundant_field_names,
         too_many_lines,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
         use_debug,
         use_self
     )

test_suite/Cargo.toml

@@ -2,9 +2,9 @@
 name = "serde_test_suite"
 version = "0.0.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+build = "build.rs"
 edition = "2018"
 publish = false
-build = "build.rs"
 
 [features]
 expandtest = []
@@ -14,13 +14,14 @@ unstable = ["serde/unstable"]
 serde = { path = "../serde" }
 
 [build-dependencies]
-toolchain_find = "0.1"
+toolchain_find = "0.2"
 
 [dev-dependencies]
 fnv = "1.0"
-macrotest = "=1.0.0"
+macrotest = "=1.0.9"
+prettyplease = "=0.1.14"
 rustversion = "1.0"
 serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
-trybuild = { version = "1.0.49", features = ["diff"] }
+trybuild = { version = "1.0.66", features = ["diff"] }

test_suite/build.rs

@@ -18,12 +18,8 @@ fn has_cargo_expand() -> bool {
         .unwrap_or(false)
 }
 
-fn has_rustfmt() -> bool {
-    toolchain_find::find_installed_component("rustfmt").is_some()
-}
-
 fn main() {
-    if cfg!(feature = "expandtest") && has_cargo_expand() && has_rustfmt() {
+    if cfg!(feature = "expandtest") && has_cargo_expand() {
         println!("cargo:rustc-cfg=expandtest");
     }
 }

test_suite/no_std/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "serde_derive_tests_no_std"
 version = "0.0.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 publish = false
 

test_suite/tests/compiletest.rs

@@ -1,5 +1,7 @@
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
+#[allow(unused_attributes)]
 #[test]
 fn ui() {
     let t = trybuild::TestCases::new();

test_suite/tests/expand/de_enum.expanded.rs

@@ -28,7 +28,12 @@ const _: () = {
         {
             match *self {
                 DeEnum::Unit => {
-                    _serde::Serializer::serialize_unit_variant(__serializer, "DeEnum", 0u32, "Unit")
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        "DeEnum",
+                        0u32,
+                        "Unit",
+                    )
                 }
                 DeEnum::Seq(ref __field0, ref __field1, ref __field2, ref __field3) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
@@ -81,12 +86,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                DeEnum::Map {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
+                DeEnum::Map { ref a, ref b, ref c, ref d } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "DeEnum",
@@ -141,13 +141,20 @@ const _: () = {
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
                 }
-                DeEnum::_Unit2 => _serde::Serializer::serialize_unit_variant(
-                    __serializer,
-                    "DeEnum",
-                    3u32,
-                    "_Unit2",
-                ),
-                DeEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
+                DeEnum::_Unit2 => {
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        "DeEnum",
+                        3u32,
+                        "_Unit2",
+                    )
+                }
+                DeEnum::_Seq2(
+                    ref __field0,
+                    ref __field1,
+                    ref __field2,
+                    ref __field3,
+                ) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
                         __serializer,
                         "DeEnum",
@@ -198,12 +205,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                DeEnum::_Map2 {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
+                DeEnum::_Map2 { ref a, ref b, ref c, ref d } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "DeEnum",
@@ -274,7 +276,9 @@ const _: () = {
         C: _serde::Deserialize<'de>,
         D: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -294,9 +298,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -307,10 +317,14 @@ const _: () = {
                         3u64 => _serde::__private::Ok(__Field::__field3),
                         4u64 => _serde::__private::Ok(__Field::__field4),
                         5u64 => _serde::__private::Ok(__Field::__field5),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 6",
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::invalid_value(
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 6",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -327,9 +341,11 @@ const _: () = {
                         "_Unit2" => _serde::__private::Ok(__Field::__field3),
                         "_Seq2" => _serde::__private::Ok(__Field::__field4),
                         "_Map2" => _serde::__private::Ok(__Field::__field5),
-                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -348,9 +364,9 @@ const _: () = {
                         b"_Map2" => _serde::__private::Ok(__Field::__field5),
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
                         }
                     }
                 }
@@ -363,7 +379,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, B, C, D>
@@ -420,7 +439,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -430,8 +450,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant DeEnum::Seq",
@@ -447,9 +466,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -467,9 +484,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -487,9 +502,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -507,9 +520,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -525,9 +536,9 @@ const _: () = {
                                             );
                                         }
                                     };
-                                    _serde::__private::Ok(DeEnum::Seq(
-                                        __field0, __field1, __field2, __field3,
-                                    ))
+                                    _serde::__private::Ok(
+                                        DeEnum::Seq(__field0, __field1, __field2, __field3),
+                                    )
                                 }
                             }
                             _serde::de::VariantAccess::tuple_variant(
@@ -554,8 +565,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -630,7 +640,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -640,8 +651,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant DeEnum::Map",
@@ -657,9 +667,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -677,9 +685,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -697,9 +703,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -717,9 +721,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -750,32 +752,28 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<i8> =
-                                        _serde::__private::None;
-                                    let mut __field1: _serde::__private::Option<B> =
-                                        _serde::__private::None;
-                                    let mut __field2: _serde::__private::Option<C> =
-                                        _serde::__private::None;
-                                    let mut __field3: _serde::__private::Option<D> =
-                                        _serde::__private::None;
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
+                                    let mut __field0: _serde::__private::Option<i8> = _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
+                                    let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
+                                    let mut __field3: _serde::__private::Option<D> = _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
+                                        = match _serde::de::MapAccess::next_key::<
+                                            __Field,
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
-                                    {
+                                        } {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i8>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<i8>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -785,12 +783,12 @@ const _: () = {
                                             }
                                             __Field::__field1 => {
                                                 if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("b")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("b"),
+                                                    );
                                                 }
                                                 __field1 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<B>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<B>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -800,12 +798,12 @@ const _: () = {
                                             }
                                             __Field::__field2 => {
                                                 if _serde::__private::Option::is_some(&__field2) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("c")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("c"),
+                                                    );
                                                 }
                                                 __field2 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<C>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<C>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -815,12 +813,12 @@ const _: () = {
                                             }
                                             __Field::__field3 => {
                                                 if _serde::__private::Option::is_some(&__field3) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("d")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("d"),
+                                                    );
                                                 }
                                                 __field3 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<D>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<D>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -831,9 +829,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
+                                                >(&mut __map) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -894,7 +890,12 @@ const _: () = {
                                     })
                                 }
                             }
-                            const FIELDS: &'static [&'static str] = &["a", "b", "c", "d"];
+                            const FIELDS: &'static [&'static str] = &[
+                                "a",
+                                "b",
+                                "c",
+                                "d",
+                            ];
                             _serde::de::VariantAccess::struct_variant(
                                 __variant,
                                 FIELDS,
@@ -923,7 +924,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -933,8 +935,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant DeEnum::_Seq2",
@@ -950,9 +951,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -970,9 +969,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -990,9 +987,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1010,9 +1005,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1028,9 +1021,9 @@ const _: () = {
                                             );
                                         }
                                     };
-                                    _serde::__private::Ok(DeEnum::_Seq2(
-                                        __field0, __field1, __field2, __field3,
-                                    ))
+                                    _serde::__private::Ok(
+                                        DeEnum::_Seq2(__field0, __field1, __field2, __field3),
+                                    )
                                 }
                             }
                             _serde::de::VariantAccess::tuple_variant(
@@ -1057,8 +1050,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -1133,7 +1125,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -1143,8 +1136,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant DeEnum::_Map2",
@@ -1160,9 +1152,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1180,9 +1170,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1200,9 +1188,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1220,9 +1206,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1253,32 +1237,28 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<i8> =
-                                        _serde::__private::None;
-                                    let mut __field1: _serde::__private::Option<B> =
-                                        _serde::__private::None;
-                                    let mut __field2: _serde::__private::Option<C> =
-                                        _serde::__private::None;
-                                    let mut __field3: _serde::__private::Option<D> =
-                                        _serde::__private::None;
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
+                                    let mut __field0: _serde::__private::Option<i8> = _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
+                                    let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
+                                    let mut __field3: _serde::__private::Option<D> = _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
+                                        = match _serde::de::MapAccess::next_key::<
+                                            __Field,
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
-                                    {
+                                        } {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i8>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<i8>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1288,12 +1268,12 @@ const _: () = {
                                             }
                                             __Field::__field1 => {
                                                 if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("b")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("b"),
+                                                    );
                                                 }
                                                 __field1 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<B>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<B>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1303,12 +1283,12 @@ const _: () = {
                                             }
                                             __Field::__field2 => {
                                                 if _serde::__private::Option::is_some(&__field2) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("c")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("c"),
+                                                    );
                                                 }
                                                 __field2 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<C>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<C>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1318,12 +1298,12 @@ const _: () = {
                                             }
                                             __Field::__field3 => {
                                                 if _serde::__private::Option::is_some(&__field3) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("d")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("d"),
+                                                    );
                                                 }
                                                 __field3 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<D>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<D>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1334,9 +1314,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
+                                                >(&mut __map) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -1397,7 +1375,12 @@ const _: () = {
                                     })
                                 }
                             }
-                            const FIELDS: &'static [&'static str] = &["a", "b", "c", "d"];
+                            const FIELDS: &'static [&'static str] = &[
+                                "a",
+                                "b",
+                                "c",
+                                "d",
+                            ];
                             _serde::de::VariantAccess::struct_variant(
                                 __variant,
                                 FIELDS,
@@ -1410,8 +1393,14 @@ const _: () = {
                     }
                 }
             }
-            const VARIANTS: &'static [&'static str] =
-                &["Unit", "Seq", "Map", "_Unit2", "_Seq2", "_Map2"];
+            const VARIANTS: &'static [&'static str] = &[
+                "Unit",
+                "Seq",
+                "Map",
+                "_Unit2",
+                "_Seq2",
+                "_Map2",
+            ];
             _serde::Deserializer::deserialize_enum(
                 __deserializer,
                 "DeEnum",

test_suite/tests/expand/default_ty_param.expanded.rs

@@ -52,8 +52,11 @@ const _: () = {
     #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
-    impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+    impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de>
+    for DefaultTyParam<T> {
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -69,9 +72,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -113,20 +122,27 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, T: AssociatedType<X = i32>> {
                 marker: _serde::__private::PhantomData<DefaultTyParam<T>>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de> for __Visitor<'de, T> {
+            impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de>
+            for __Visitor<'de, T> {
                 type Value = DefaultTyParam<T>;
                 fn expecting(
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DefaultTyParam",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -136,9 +152,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>(
-                        &mut __seq,
-                    ) {
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
+                        PhantomData<T>,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -146,13 +162,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"struct DefaultTyParam with 1 element",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    0usize,
+                                    &"struct DefaultTyParam with 1 element",
+                                ),
+                            );
                         }
                     };
-                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam {
+                        phantom: __field0,
+                    })
                 }
                 #[inline]
                 fn visit_map<__A>(
@@ -162,16 +182,14 @@ const _: () = {
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::__private::Option<PhantomData<T>> =
-                        _serde::__private::None;
-                    while let _serde::__private::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                    let mut __field0: _serde::__private::Option<PhantomData<T>> = _serde::__private::None;
+                    while let _serde::__private::Some(__key)
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
-                    {
+                        } {
                         match __key {
                             __Field::__field0 => {
                                 if _serde::__private::Option::is_some(&__field0) {
@@ -182,9 +200,9 @@ const _: () = {
                                     );
                                 }
                                 __field0 = _serde::__private::Some(
-                                    match _serde::de::MapAccess::next_value::<PhantomData<T>>(
-                                        &mut __map,
-                                    ) {
+                                    match _serde::de::MapAccess::next_value::<
+                                        PhantomData<T>,
+                                    >(&mut __map) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -195,8 +213,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
+                                >(&mut __map) {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -216,7 +233,9 @@ const _: () = {
                             }
                         }
                     };
-                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam {
+                        phantom: __field0,
+                    })
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -249,9 +268,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -293,22 +318,30 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> {
                 place: &'place mut DefaultTyParam<T>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de>
-                for __Visitor<'de, 'place, T>
-            {
+            impl<
+                'de,
+                'place,
+                T: AssociatedType<X = i32> + 'place,
+            > _serde::de::Visitor<'de> for __Visitor<'de, 'place, T> {
                 type Value = ();
                 fn expecting(
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DefaultTyParam",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -318,19 +351,22 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"struct DefaultTyParam with 1 element",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                0usize,
+                                &"struct DefaultTyParam with 1 element",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }
@@ -343,14 +379,13 @@ const _: () = {
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::__private::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                    while let _serde::__private::Some(__key)
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
-                    {
+                        } {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
@@ -374,8 +409,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
+                                >(&mut __map) {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -385,13 +419,17 @@ const _: () = {
                         }
                     }
                     if !__field0 {
-                        self.place.phantom = match _serde::__private::de::missing_field("phantom") {
+                        self
+                            .place
+                            .phantom = match _serde::__private::de::missing_field(
+                            "phantom",
+                        ) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
                         };
-                    };
+                    }
                     _serde::__private::Ok(())
                 }
             }

test_suite/tests/expand/generic_enum.expanded.rs

@@ -24,12 +24,14 @@ const _: () = {
             __S: _serde::Serializer,
         {
             match *self {
-                GenericEnum::Unit => _serde::Serializer::serialize_unit_variant(
-                    __serializer,
-                    "GenericEnum",
-                    0u32,
-                    "Unit",
-                ),
+                GenericEnum::Unit => {
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        "GenericEnum",
+                        0u32,
+                        "Unit",
+                    )
+                }
                 GenericEnum::NewType(ref __field0) => {
                     _serde::Serializer::serialize_newtype_variant(
                         __serializer,
@@ -122,7 +124,9 @@ const _: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -140,9 +144,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -151,10 +161,14 @@ const _: () = {
                         1u64 => _serde::__private::Ok(__Field::__field1),
                         2u64 => _serde::__private::Ok(__Field::__field2),
                         3u64 => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 4",
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::invalid_value(
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 4",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -169,9 +183,11 @@ const _: () = {
                         "NewType" => _serde::__private::Ok(__Field::__field1),
                         "Seq" => _serde::__private::Ok(__Field::__field2),
                         "Map" => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -188,9 +204,9 @@ const _: () = {
                         b"Map" => _serde::__private::Ok(__Field::__field3),
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
                         }
                     }
                 }
@@ -203,7 +219,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, T, U>
@@ -224,7 +243,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "enum GenericEnum")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "enum GenericEnum",
+                    )
                 }
                 fn visit_enum<__A>(
                     self,
@@ -248,10 +270,12 @@ const _: () = {
                             };
                             _serde::__private::Ok(GenericEnum::Unit)
                         }
-                        (__Field::__field1, __variant) => _serde::__private::Result::map(
-                            _serde::de::VariantAccess::newtype_variant::<T>(__variant),
-                            GenericEnum::NewType,
-                        ),
+                        (__Field::__field1, __variant) => {
+                            _serde::__private::Result::map(
+                                _serde::de::VariantAccess::newtype_variant::<T>(__variant),
+                                GenericEnum::NewType,
+                            )
+                        }
                         (__Field::__field2, __variant) => {
                             struct __Visitor<'de, T, U>
                             where
@@ -261,7 +285,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
+                            impl<'de, T, U> _serde::de::Visitor<'de>
+                            for __Visitor<'de, T, U>
                             where
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
@@ -270,8 +295,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant GenericEnum::Seq",
@@ -287,9 +311,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         T,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -297,14 +319,17 @@ const _: () = {
                                     } {
                                         _serde::__private::Some(__value) => __value,
                                         _serde::__private::None => {
-                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    0usize,
+                                                    &"tuple variant GenericEnum::Seq with 2 elements",
+                                                ),
+                                            );
                                         }
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         U,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -312,7 +337,12 @@ const _: () = {
                                     } {
                                         _serde::__private::Some(__value) => __value,
                                         _serde::__private::None => {
-                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    1usize,
+                                                    &"tuple variant GenericEnum::Seq with 2 elements",
+                                                ),
+                                            );
                                         }
                                     };
                                     _serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
@@ -340,8 +370,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -409,7 +438,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
+                            impl<'de, T, U> _serde::de::Visitor<'de>
+                            for __Visitor<'de, T, U>
                             where
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
@@ -418,8 +448,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant GenericEnum::Map",
@@ -435,9 +464,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         T,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -445,14 +472,17 @@ const _: () = {
                                     } {
                                         _serde::__private::Some(__value) => __value,
                                         _serde::__private::None => {
-                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant GenericEnum::Map with 2 elements")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    0usize,
+                                                    &"struct variant GenericEnum::Map with 2 elements",
+                                                ),
+                                            );
                                         }
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         U,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -460,7 +490,12 @@ const _: () = {
                                     } {
                                         _serde::__private::Some(__value) => __value,
                                         _serde::__private::None => {
-                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "struct variant GenericEnum::Map with 2 elements")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    1usize,
+                                                    &"struct variant GenericEnum::Map with 2 elements",
+                                                ),
+                                            );
                                         }
                                     };
                                     _serde::__private::Ok(GenericEnum::Map {
@@ -476,28 +511,26 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<T> =
-                                        _serde::__private::None;
-                                    let mut __field1: _serde::__private::Option<U> =
-                                        _serde::__private::None;
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
+                                    let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<U> = _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
+                                        = match _serde::de::MapAccess::next_key::<
+                                            __Field,
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
-                                    {
+                                        } {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("x")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("x"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<T>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<T>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -507,12 +540,12 @@ const _: () = {
                                             }
                                             __Field::__field1 => {
                                                 if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("y")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("y"),
+                                                    );
                                                 }
                                                 __field1 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<U>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<U>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -523,9 +556,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
+                                                >(&mut __map) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);

test_suite/tests/expand/generic_struct.expanded.rs

@@ -29,7 +29,11 @@ const _: () = {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "x",
+                &self.x,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
@@ -49,7 +53,9 @@ const _: () = {
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -65,9 +71,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -109,7 +121,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, T>
@@ -128,7 +143,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct GenericStruct",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -138,8 +156,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
-                    {
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
+                        T,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -147,10 +166,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"struct GenericStruct with 1 element",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    0usize,
+                                    &"struct GenericStruct with 1 element",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(GenericStruct { x: __field0 })
@@ -164,14 +185,13 @@ const _: () = {
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
-                    while let _serde::__private::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                    while let _serde::__private::Some(__key)
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
-                    {
+                        } {
                         match __key {
                             __Field::__field0 => {
                                 if _serde::__private::Option::is_some(&__field0) {
@@ -191,8 +211,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
+                                >(&mut __map) {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -245,9 +264,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -289,7 +314,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'place, T: 'place>
@@ -299,7 +327,8 @@ const _: () = {
                 place: &'place mut GenericStruct<T>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
+            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
+            for __Visitor<'de, 'place, T>
             where
                 T: _serde::Deserialize<'de>,
             {
@@ -308,7 +337,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct GenericStruct",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -318,19 +350,22 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.x),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"struct GenericStruct with 1 element",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.x),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                0usize,
+                                &"struct GenericStruct with 1 element",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }
@@ -343,14 +378,13 @@ const _: () = {
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::__private::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                    while let _serde::__private::Some(__key)
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
-                    {
+                        } {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
@@ -372,8 +406,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
+                                >(&mut __map) {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -383,13 +416,15 @@ const _: () = {
                         }
                     }
                     if !__field0 {
-                        self.place.x = match _serde::__private::de::missing_field("x") {
+                        self
+                            .place
+                            .x = match _serde::__private::de::missing_field("x") {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
                         };
-                    };
+                    }
                     _serde::__private::Ok(())
                 }
             }
@@ -442,7 +477,9 @@ const _: () = {
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -475,7 +512,9 @@ const _: () = {
                 where
                     __E: _serde::Deserializer<'de>,
                 {
-                    let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
+                    let __field0: T = match <T as _serde::Deserialize>::deserialize(
+                        __e,
+                    ) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -491,8 +530,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
-                    {
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
+                        T,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -500,10 +540,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"tuple struct GenericNewTypeStruct with 1 element",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    0usize,
+                                    &"tuple struct GenericNewTypeStruct with 1 element",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(GenericNewTypeStruct(__field0))
@@ -532,7 +574,8 @@ const _: () = {
                 place: &'place mut GenericNewTypeStruct<T>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
+            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
+            for __Visitor<'de, 'place, T>
             where
                 T: _serde::Deserialize<'de>,
             {
@@ -564,19 +607,22 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"tuple struct GenericNewTypeStruct with 1 element",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.0),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                0usize,
+                                &"tuple struct GenericNewTypeStruct with 1 element",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }

test_suite/tests/expand/generic_tuple_struct.expanded.rs

@@ -11,7 +11,9 @@ const _: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -46,8 +48,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
-                    {
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
+                        T,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -55,14 +58,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"tuple struct GenericTupleStruct with 2 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    0usize,
+                                    &"tuple struct GenericTupleStruct with 2 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field1 = match match _serde::de::SeqAccess::next_element::<U>(&mut __seq)
-                    {
+                    let __field1 = match match _serde::de::SeqAccess::next_element::<
+                        U,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -70,10 +76,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                1usize,
-                                &"tuple struct GenericTupleStruct with 2 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    1usize,
+                                    &"tuple struct GenericTupleStruct with 2 elements",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(GenericTupleStruct(__field0, __field1))
@@ -104,7 +112,8 @@ const _: () = {
                 place: &'place mut GenericTupleStruct<T, U>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U>
+            impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de>
+            for __Visitor<'de, 'place, T, U>
             where
                 T: _serde::Deserialize<'de>,
                 U: _serde::Deserialize<'de>,
@@ -127,33 +136,39 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"tuple struct GenericTupleStruct with 2 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.0),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                0usize,
+                                &"tuple struct GenericTupleStruct with 2 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            1usize,
-                            &"tuple struct GenericTupleStruct with 2 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.1),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                1usize,
+                                &"tuple struct GenericTupleStruct with 2 elements",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }

test_suite/tests/expand/lifetimes.expanded.rs

@@ -99,7 +99,9 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -117,9 +119,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -128,10 +136,14 @@ const _: () = {
                         1u64 => _serde::__private::Ok(__Field::__field1),
                         2u64 => _serde::__private::Ok(__Field::__field2),
                         3u64 => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 4",
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::invalid_value(
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 4",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -146,9 +158,11 @@ const _: () = {
                         "NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
                         "LifetimeMap" => _serde::__private::Ok(__Field::__field2),
                         "NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -165,9 +179,9 @@ const _: () = {
                         b"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
                         }
                     }
                 }
@@ -180,7 +194,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'a> {
@@ -193,7 +210,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "enum Lifetimes")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "enum Lifetimes",
+                    )
                 }
                 fn visit_enum<__A>(
                     self,
@@ -208,14 +228,22 @@ const _: () = {
                             return _serde::__private::Err(__err);
                         }
                     } {
-                        (__Field::__field0, __variant) => _serde::__private::Result::map(
-                            _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
-                            Lifetimes::LifetimeSeq,
-                        ),
-                        (__Field::__field1, __variant) => _serde::__private::Result::map(
-                            _serde::de::VariantAccess::newtype_variant::<i32>(__variant),
-                            Lifetimes::NoLifetimeSeq,
-                        ),
+                        (__Field::__field0, __variant) => {
+                            _serde::__private::Result::map(
+                                _serde::de::VariantAccess::newtype_variant::<
+                                    &'a i32,
+                                >(__variant),
+                                Lifetimes::LifetimeSeq,
+                            )
+                        }
+                        (__Field::__field1, __variant) => {
+                            _serde::__private::Result::map(
+                                _serde::de::VariantAccess::newtype_variant::<
+                                    i32,
+                                >(__variant),
+                                Lifetimes::NoLifetimeSeq,
+                            )
+                        }
                         (__Field::__field2, __variant) => {
                             #[allow(non_camel_case_types)]
                             enum __Field {
@@ -228,8 +256,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -290,13 +317,13 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<Lifetimes<'a>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
+                            impl<'de, 'a> _serde::de::Visitor<'de>
+                            for __Visitor<'de, 'a> {
                                 type Value = Lifetimes<'a>;
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::LifetimeMap",
@@ -312,9 +339,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         &'a i32,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -322,10 +347,17 @@ const _: () = {
                                     } {
                                         _serde::__private::Some(__value) => __value,
                                         _serde::__private::None => {
-                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::LifetimeMap with 1 element")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    0usize,
+                                                    &"struct variant Lifetimes::LifetimeMap with 1 element",
+                                                ),
+                                            );
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
@@ -335,26 +367,27 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<&'a i32> =
-                                        _serde::__private::None;
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
+                                    let mut __field0: _serde::__private::Option<&'a i32> = _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
+                                        = match _serde::de::MapAccess::next_key::<
+                                            __Field,
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
-                                    {
+                                        } {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<&'a i32>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<
+                                                        &'a i32,
+                                                    >(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -365,9 +398,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
+                                                >(&mut __map) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -387,7 +418,9 @@ const _: () = {
                                             }
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -412,8 +445,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -474,13 +506,13 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<Lifetimes<'a>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
+                            impl<'de, 'a> _serde::de::Visitor<'de>
+                            for __Visitor<'de, 'a> {
                                 type Value = Lifetimes<'a>;
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
-                                {
+                                ) -> _serde::__private::fmt::Result {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::NoLifetimeMap",
@@ -496,9 +528,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i32,
-                                    >(
-                                        &mut __seq
-                                    ) {
+                                    >(&mut __seq) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -506,10 +536,17 @@ const _: () = {
                                     } {
                                         _serde::__private::Some(__value) => __value,
                                         _serde::__private::None => {
-                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    0usize,
+                                                    &"struct variant Lifetimes::NoLifetimeMap with 1 element",
+                                                ),
+                                            );
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
@@ -519,26 +556,25 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<i32> =
-                                        _serde::__private::None;
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
+                                    let mut __field0: _serde::__private::Option<i32> = _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
+                                        = match _serde::de::MapAccess::next_key::<
+                                            __Field,
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
-                                    {
+                                        } {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i32>(
-                                                        &mut __map,
-                                                    ) {
+                                                    match _serde::de::MapAccess::next_value::<i32>(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -549,9 +585,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
+                                                >(&mut __map) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -571,7 +605,9 @@ const _: () = {
                                             }
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];

test_suite/tests/expand/named_map.expanded.rs

@@ -33,19 +33,31 @@ const _: () = {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "a",
+                &self.a,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "b",
+                &self.b,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "c",
+                &self.c,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
@@ -72,7 +84,9 @@ const _: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -90,9 +104,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -140,7 +160,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, A, B, C>
@@ -163,7 +186,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DeNamedMap",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -173,8 +199,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
-                    {
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
+                        A,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -182,14 +209,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"struct DeNamedMap with 3 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    0usize,
+                                    &"struct DeNamedMap with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
-                    {
+                    let __field1 = match match _serde::de::SeqAccess::next_element::<
+                        B,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -197,14 +227,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                1usize,
-                                &"struct DeNamedMap with 3 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    1usize,
+                                    &"struct DeNamedMap with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
-                    {
+                    let __field2 = match match _serde::de::SeqAccess::next_element::<
+                        C,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -212,10 +245,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                2usize,
-                                &"struct DeNamedMap with 3 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    2usize,
+                                    &"struct DeNamedMap with 3 elements",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(DeNamedMap {
@@ -235,14 +270,13 @@ const _: () = {
                     let mut __field0: _serde::__private::Option<A> = _serde::__private::None;
                     let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
                     let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
-                    while let _serde::__private::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                    while let _serde::__private::Some(__key)
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
-                    {
+                        } {
                         match __key {
                             __Field::__field0 => {
                                 if _serde::__private::Option::is_some(&__field0) {
@@ -292,8 +326,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
+                                >(&mut __map) {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -374,9 +407,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -424,7 +463,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place>
@@ -437,7 +479,7 @@ const _: () = {
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
-                for __Visitor<'de, 'place, A, B, C>
+            for __Visitor<'de, 'place, A, B, C>
             where
                 A: _serde::Deserialize<'de>,
                 B: _serde::Deserialize<'de>,
@@ -448,7 +490,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DeNamedMap",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -458,47 +503,56 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.a),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"struct DeNamedMap with 3 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.a),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                0usize,
+                                &"struct DeNamedMap with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.b),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            1usize,
-                            &"struct DeNamedMap with 3 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.b),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                1usize,
+                                &"struct DeNamedMap with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.c),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            2usize,
-                            &"struct DeNamedMap with 3 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.c),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                2usize,
+                                &"struct DeNamedMap with 3 elements",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }
@@ -513,14 +567,13 @@ const _: () = {
                     let mut __field0: bool = false;
                     let mut __field1: bool = false;
                     let mut __field2: bool = false;
-                    while let _serde::__private::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                    while let _serde::__private::Some(__key)
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
-                    {
+                        } {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
@@ -576,8 +629,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
+                                >(&mut __map) {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -587,29 +639,35 @@ const _: () = {
                         }
                     }
                     if !__field0 {
-                        self.place.a = match _serde::__private::de::missing_field("a") {
+                        self
+                            .place
+                            .a = match _serde::__private::de::missing_field("a") {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
                         };
-                    };
+                    }
                     if !__field1 {
-                        self.place.b = match _serde::__private::de::missing_field("b") {
+                        self
+                            .place
+                            .b = match _serde::__private::de::missing_field("b") {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
                         };
-                    };
+                    }
                     if !__field2 {
-                        self.place.c = match _serde::__private::de::missing_field("c") {
+                        self
+                            .place
+                            .c = match _serde::__private::de::missing_field("c") {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
                         };
-                    };
+                    }
                     _serde::__private::Ok(())
                 }
             }

test_suite/tests/expand/named_tuple.expanded.rs

@@ -29,19 +29,28 @@ const _: () = {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) {
+            match _serde::ser::SerializeTupleStruct::serialize_field(
+                &mut __serde_state,
+                &self.0,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) {
+            match _serde::ser::SerializeTupleStruct::serialize_field(
+                &mut __serde_state,
+                &self.1,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) {
+            match _serde::ser::SerializeTupleStruct::serialize_field(
+                &mut __serde_state,
+                &self.2,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
@@ -64,7 +73,9 @@ const _: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -101,8 +112,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
-                    {
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
+                        A,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -110,14 +122,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"tuple struct DeNamedTuple with 3 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    0usize,
+                                    &"tuple struct DeNamedTuple with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
-                    {
+                    let __field1 = match match _serde::de::SeqAccess::next_element::<
+                        B,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -125,14 +140,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                1usize,
-                                &"tuple struct DeNamedTuple with 3 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    1usize,
+                                    &"tuple struct DeNamedTuple with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
-                    {
+                    let __field2 = match match _serde::de::SeqAccess::next_element::<
+                        C,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -140,10 +158,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
-                                2usize,
-                                &"tuple struct DeNamedTuple with 3 elements",
-                            ));
+                            return _serde::__private::Err(
+                                _serde::de::Error::invalid_length(
+                                    2usize,
+                                    &"tuple struct DeNamedTuple with 3 elements",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
@@ -176,7 +196,7 @@ const _: () = {
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
-                for __Visitor<'de, 'place, A, B, C>
+            for __Visitor<'de, 'place, A, B, C>
             where
                 A: _serde::Deserialize<'de>,
                 B: _serde::Deserialize<'de>,
@@ -200,47 +220,56 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"tuple struct DeNamedTuple with 3 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.0),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                0usize,
+                                &"tuple struct DeNamedTuple with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            1usize,
-                            &"tuple struct DeNamedTuple with 3 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.1),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                1usize,
+                                &"tuple struct DeNamedTuple with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::__private::de::InPlaceSeed(&mut self.place.2),
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
-                            2usize,
-                            &"tuple struct DeNamedTuple with 3 elements",
-                        ));
+                    if let _serde::__private::None
+                        = match _serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.2),
+                        ) {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
+                            }
+                        } {
+                        return _serde::__private::Err(
+                            _serde::de::Error::invalid_length(
+                                2usize,
+                                &"tuple struct DeNamedTuple with 3 elements",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }

test_suite/tests/expand/named_unit.expanded.rs

@@ -25,7 +25,9 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de> _serde::Deserialize<'de> for NamedUnit {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -36,7 +38,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "unit struct NamedUnit")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "unit struct NamedUnit",
+                    )
                 }
                 #[inline]
                 fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
@@ -46,7 +51,11 @@ const _: () = {
                     _serde::__private::Ok(NamedUnit)
                 }
             }
-            _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor)
+            _serde::Deserializer::deserialize_unit_struct(
+                __deserializer,
+                "NamedUnit",
+                __Visitor,
+            )
         }
     }
 };

test_suite/tests/expand/ser_enum.expanded.rs

@@ -31,12 +31,14 @@ const _: () = {
             __S: _serde::Serializer,
         {
             match *self {
-                SerEnum::Unit => _serde::Serializer::serialize_unit_variant(
-                    __serializer,
-                    "SerEnum",
-                    0u32,
-                    "Unit",
-                ),
+                SerEnum::Unit => {
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        "SerEnum",
+                        0u32,
+                        "Unit",
+                    )
+                }
                 SerEnum::Seq(ref __field0, ref __field1, ref __field2, ref __field3) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
                         __serializer,
@@ -88,12 +90,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                SerEnum::Map {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
+                SerEnum::Map { ref a, ref b, ref c, ref d } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "SerEnum",
@@ -148,13 +145,20 @@ const _: () = {
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
                 }
-                SerEnum::_Unit2 => _serde::Serializer::serialize_unit_variant(
-                    __serializer,
-                    "SerEnum",
-                    3u32,
-                    "_Unit2",
-                ),
-                SerEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
+                SerEnum::_Unit2 => {
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        "SerEnum",
+                        3u32,
+                        "_Unit2",
+                    )
+                }
+                SerEnum::_Seq2(
+                    ref __field0,
+                    ref __field1,
+                    ref __field2,
+                    ref __field3,
+                ) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
                         __serializer,
                         "SerEnum",
@@ -205,12 +209,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                SerEnum::_Map2 {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
+                SerEnum::_Map2 { ref a, ref b, ref c, ref d } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "SerEnum",

test_suite/tests/expand/void.expanded.rs

@@ -25,7 +25,9 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de> _serde::Deserialize<'de> for Void {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -38,17 +40,27 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 0",
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::invalid_value(
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 0",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -59,9 +71,11 @@ const _: () = {
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
+                        _ => {
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -74,9 +88,9 @@ const _: () = {
                     match __value {
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
+                            _serde::__private::Err(
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
                         }
                     }
                 }
@@ -89,7 +103,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de> {

test_suite/tests/expandtest.rs

@@ -1,6 +1,7 @@
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[cfg_attr(not(expandtest), ignore)]
 #[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
 #[allow(unused_attributes)]
 #[test]
 fn expandtest() {

test_suite/tests/macros/mod.rs

@@ -1,93 +1,79 @@
+#![allow(unused_macro_rules)]
+
+use serde_test::Token;
+use std::iter;
+
 macro_rules! btreeset {
     () => {
         BTreeSet::new()
     };
-    ($($value:expr),+) => {
-        {
-            let mut set = BTreeSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    }
+    ($($value:expr),+) => {{
+        let mut set = BTreeSet::new();
+        $(set.insert($value);)+
+        set
+    }};
 }
 
 macro_rules! btreemap {
     () => {
         BTreeMap::new()
     };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
+    ($($key:expr => $value:expr),+) => {{
+        let mut map = BTreeMap::new();
+        $(map.insert($key, $value);)+
+        map
+    }};
 }
 
 macro_rules! hashset {
     () => {
         HashSet::new()
     };
-    ($($value:expr),+) => {
-        {
-            let mut set = HashSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    };
-    ($hasher:ident @ $($value:expr),+) => {
-        {
-            use std::hash::BuildHasherDefault;
-            let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
-            $(set.insert($value);)+
-            set
-        }
-    }
+    ($($value:expr),+) => {{
+        let mut set = HashSet::new();
+        $(set.insert($value);)+
+        set
+    }};
+    ($hasher:ident @ $($value:expr),+) => {{
+        use std::hash::BuildHasherDefault;
+        let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
+        $(set.insert($value);)+
+        set
+    }};
 }
 
 macro_rules! hashmap {
     () => {
         HashMap::new()
     };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = HashMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    };
-    ($hasher:ident @ $($key:expr => $value:expr),+) => {
-        {
-            use std::hash::BuildHasherDefault;
-            let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
-            $(map.insert($key, $value);)+
-            map
-        }
+    ($($key:expr => $value:expr),+) => {{
+        let mut map = HashMap::new();
+        $(map.insert($key, $value);)+
+        map
+    }};
+    ($hasher:ident @ $($key:expr => $value:expr),+) => {{
+        use std::hash::BuildHasherDefault;
+        let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
+        $(map.insert($key, $value);)+
+        map
+    }};
+}
+
+pub trait SingleTokenIntoIterator {
+    fn into_iter(self) -> iter::Once<Token>;
+}
+
+impl SingleTokenIntoIterator for Token {
+    fn into_iter(self) -> iter::Once<Token> {
+        iter::once(self)
     }
 }
 
-macro_rules! seq_impl {
-    (seq $first:expr,) => {
-        seq_impl!(seq $first)
-    };
-    ($first:expr,) => {
-        seq_impl!($first)
-    };
-    (seq $first:expr) => {
-        $first.into_iter()
-    };
-    ($first:expr) => {
-        Some($first).into_iter()
-    };
-    (seq $first:expr , $( $elem: tt)*) => {
-        $first.into_iter().chain(seq!( $($elem)* ))
-    };
-    ($first:expr , $($elem: tt)*) => {
-        Some($first).into_iter().chain(seq!( $($elem)* ))
-    }
-}
 macro_rules! seq {
-    ($($tt: tt)*) => {
-        seq_impl!($($tt)*).collect::<Vec<_>>()
-    };
+    ($($elem:expr),* $(,)?) => {{
+        use crate::macros::SingleTokenIntoIterator;
+        let mut vec = Vec::new();
+        $(<Vec<Token> as Extend<Token>>::extend(&mut vec, $elem.into_iter());)*
+        vec
+    }};
 }

test_suite/tests/test_annotations.rs

@@ -1,10 +1,12 @@
 #![allow(
     clippy::cast_lossless,
+    clippy::derive_partial_eq_without_eq,
     clippy::from_over_into,
     // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
     clippy::nonstandard_macro_braces,
     clippy::too_many_lines,
-    clippy::trivially_copy_pass_by_ref
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
 )]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
@@ -1233,7 +1235,7 @@ fn serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> Result<S:
 where
     S: Serializer,
 {
-    serializer.serialize_str(format!("{};{:?}", f1, f2).as_str())
+    serializer.serialize_str(format!("{f1};{f2:?}").as_str())
 }
 
 fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
@@ -1242,22 +1244,17 @@ where
 {
     let s = String::deserialize(deserializer)?;
     let mut pieces = s.split(';');
-    let f1 = match pieces.next() {
-        Some(x) => x,
-        None => return Err(de::Error::invalid_length(0, &"2")),
+    let Some(f1) = pieces.next() else {
+        return Err(de::Error::invalid_length(0, &"2"));
     };
-    let f2 = match pieces.next() {
-        Some(x) => x,
-        None => return Err(de::Error::invalid_length(1, &"2")),
+    let Some(f2) = pieces.next() else {
+        return Err(de::Error::invalid_length(1, &"2"));
     };
-    let f2 = match f2.parse() {
-        Ok(n) => n,
-        Err(_) => {
-            return Err(de::Error::invalid_value(
-                Unexpected::Str(f2),
-                &"an 8-bit signed integer",
-            ));
-        }
+    let Ok(f2) = f2.parse() else {
+        return Err(de::Error::invalid_value(
+            Unexpected::Str(f2),
+            &"an 8-bit signed integer",
+        ));
     };
     Ok((f1.into(), f2))
 }
@@ -2300,6 +2297,25 @@ fn test_internally_tagged_enum_containing_flatten() {
     );
 }
 
+#[test]
+fn test_internally_tagged_enum_new_type_with_unit() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A(()),
+    }
+
+    assert_tokens(
+        &Data::A(()),
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_adjacently_tagged_enum_containing_flatten() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]

test_suite/tests/test_borrow.rs

@@ -1,4 +1,8 @@
-#![allow(clippy::items_after_statements, clippy::used_underscore_binding)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::items_after_statements,
+    clippy::used_underscore_binding
+)]
 
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};

test_suite/tests/test_gen.rs

@@ -6,6 +6,7 @@
 #![allow(
     unknown_lints,
     mixed_script_confusables,
+    clippy::derive_partial_eq_without_eq,
     clippy::items_after_statements,
     clippy::missing_errors_doc,
     clippy::missing_panics_doc,
@@ -14,7 +15,8 @@
     clippy::nonstandard_macro_braces,
     clippy::ptr_arg,
     clippy::too_many_lines,
-    clippy::trivially_copy_pass_by_ref
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
 )]
 
 use serde::de::DeserializeOwned;

test_suite/tests/test_identifier.rs

@@ -1,4 +1,7 @@
 //! Tests for `#[serde(field_identifier)]` and `#[serde(variant_identifier)]`
+
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 use serde::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 

test_suite/tests/test_ignored_any.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 use serde::de::value::{Error, MapDeserializer, SeqDeserializer};
 use serde::de::{
     DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,

test_suite/tests/test_macros.rs

@@ -1,5 +1,6 @@
 #![deny(trivial_numeric_casts)]
 #![allow(
+    clippy::derive_partial_eq_without_eq,
     clippy::enum_variant_names,
     clippy::redundant_field_names,
     clippy::too_many_lines

test_suite/tests/test_remote.rs

@@ -74,6 +74,21 @@ mod remote {
             &self.b
         }
     }
+
+    pub struct StructGeneric<T> {
+        pub value: T,
+    }
+
+    impl<T> StructGeneric<T> {
+        #[allow(dead_code)]
+        pub fn get_value(&self) -> &T {
+            &self.value
+        }
+    }
+
+    pub enum EnumGeneric<T> {
+        Variant(T),
+    }
 }
 
 #[derive(Serialize, Deserialize)]
@@ -104,6 +119,12 @@ struct Test {
 
     #[serde(with = "StructPubDef")]
     struct_pub: remote::StructPub,
+
+    #[serde(with = "StructConcrete")]
+    struct_concrete: remote::StructGeneric<u8>,
+
+    #[serde(with = "EnumConcrete")]
+    enum_concrete: remote::EnumGeneric<u8>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -157,6 +178,25 @@ struct StructPubDef {
     b: remote::Unit,
 }
 
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "remote::StructGeneric")]
+struct StructGenericWithGetterDef<T> {
+    #[serde(getter = "remote::StructGeneric::get_value")]
+    value: T,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "remote::StructGeneric<u8>")]
+struct StructConcrete {
+    value: u8,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "remote::EnumGeneric<u8>")]
+enum EnumConcrete {
+    Variant(u8),
+}
+
 impl From<PrimitivePrivDef> for remote::PrimitivePriv {
     fn from(def: PrimitivePrivDef) -> Self {
         remote::PrimitivePriv::new(def.0)
@@ -180,3 +220,9 @@ impl From<StructPrivDef> for remote::StructPriv {
         remote::StructPriv::new(def.a, def.b)
     }
 }
+
+impl<T> From<StructGenericWithGetterDef<T>> for remote::StructGeneric<T> {
+    fn from(def: StructGenericWithGetterDef<T>) -> Self {
+        remote::StructGeneric { value: def.value }
+    }
+}

test_suite/tests/test_roundtrip.rs

@@ -11,10 +11,12 @@ fn ip_addr_roundtrip() {
     assert_tokens(
         &net::IpAddr::from(*b"1234").compact(),
         &seq![
-            Token::NewtypeVariant { name: "IpAddr", variant: "V4" },
-
+            Token::NewtypeVariant {
+                name: "IpAddr",
+                variant: "V4"
+            },
             Token::Tuple { len: 4 },
-            seq b"1234".iter().map(|&b| Token::U8(b)),
+            b"1234".iter().copied().map(Token::U8),
             Token::TupleEnd,
         ],
     );
@@ -25,14 +27,14 @@ fn socket_addr_roundtrip() {
     assert_tokens(
         &net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
         &seq![
-            Token::NewtypeVariant { name: "SocketAddr", variant: "V6" },
-
+            Token::NewtypeVariant {
+                name: "SocketAddr",
+                variant: "V6"
+            },
             Token::Tuple { len: 2 },
-
             Token::Tuple { len: 16 },
-            seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
+            b"1234567890123456".iter().copied().map(Token::U8),
             Token::TupleEnd,
-
             Token::U16(1234),
             Token::TupleEnd,
         ],

test_suite/tests/test_unstable.rs

@@ -1,4 +1,5 @@
 #![deny(warnings)]
+#![allow(clippy::derive_partial_eq_without_eq)]
 
 // This test target is convoluted with the actual #[test] in a separate file to
 // get it so that the stable compiler does not need to parse the code of the

test_suite/tests/test_value.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::similar_names)]
+#![allow(clippy::derive_partial_eq_without_eq, clippy::similar_names)]
 
 use serde::de::value::{self, MapAccessDeserializer};
 use serde::de::{IntoDeserializer, MapAccess, Visitor};
@@ -19,7 +19,6 @@ fn test_u32_to_enum() {
     assert_eq!(E::B, e);
 }
 
-#[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))]
 #[test]
 fn test_integer128() {
     let de_u128 = IntoDeserializer::<value::Error>::into_deserializer(1u128);

test_suite/tests/ui/remote/double_generic.rs

@@ -0,0 +1,17 @@
+use serde_derive::{Deserialize, Serialize};
+
+mod remote {
+    pub struct Struct<T, U> {
+        pub t: T,
+        pub u: U,
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "remote::StructGeneric<u8>")]
+struct StructDef<U> {
+    t: u8,
+    u: U,
+}
+
+fn main() {}

test_suite/tests/ui/remote/double_generic.stderr

@@ -0,0 +1,5 @@
+error: remove generic parameters from this path
+  --> tests/ui/remote/double_generic.rs:11:18
+   |
+11 | #[serde(remote = "remote::StructGeneric<u8>")]
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^

test_suite/tests/ui/remote/wrong_de.stderr

@@ -3,7 +3,14 @@ error[E0308]: mismatched types
   |
 7 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^ expected `u16`, found `u8`
+8 | #[serde(remote = "remote::S")]
+  |                  ----------- arguments to this struct are incorrect
   |
+note: tuple struct defined here
+ --> tests/ui/remote/wrong_de.rs:4:16
+  |
+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`
   |

test_suite/tests/ui/remote/wrong_getter.stderr

@@ -2,8 +2,16 @@ error[E0308]: mismatched types
   --> tests/ui/remote/wrong_getter.rs:15:10
    |
 15 | #[derive(Serialize)]
-   |          ^^^^^^^^^ expected `u8`, found `u16`
+   |          ^^^^^^^^^
+   |          |
+   |          expected `u8`, found `u16`
+   |          arguments to this function are incorrect
    |
    = note: expected reference `&u8`
               found reference `&u16`
+note: function defined here
+  --> $WORKSPACE/serde/src/private/ser.rs
+   |
+   | pub fn constrain<T: ?Sized>(t: &T) -> &T {
+   |        ^^^^^^^^^
    = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)

test_suite/tests/ui/remote/wrong_ser.stderr

@@ -2,8 +2,16 @@ error[E0308]: mismatched types
  --> tests/ui/remote/wrong_ser.rs:9:10
   |
 9 | #[derive(Serialize)]
-  |          ^^^^^^^^^ expected `u8`, found `u16`
+  |          ^^^^^^^^^
+  |          |
+  |          expected `u8`, found `u16`
+  |          arguments to this function are incorrect
   |
   = note: expected reference `&u8`
              found reference `&u16`
+note: function defined here
+ --> $WORKSPACE/serde/src/private/ser.rs
+  |
+  | pub fn constrain<T: ?Sized>(t: &T) -> &T {
+  |        ^^^^^^^^^
   = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)