Release 1.0.145

Serialize unsized `RefCell`, `Mutex` and `RwLock`

.gitattributes

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

.github/workflows/ci.yml

@@ -5,43 +5,50 @@ on:
   pull_request:
   schedule: [cron: "40 1 * * *"]
 
+permissions:
+  contents: read
+
+env:
+  RUSTFLAGS: -Dwarnings
+
 jobs:
   test:
     name: Test suite
     runs-on: ubuntu-latest
     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
     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
 
   stable:
-    name: Rust stable
+    name: Rust ${{matrix.rust}}
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [stable, beta]
     steps:
-      - uses: actions/checkout@v2
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
       - run: cd serde && cargo build --features rc
       - run: cd serde && cargo build --no-default-features
       - run: cd serde_test && cargo build
       - run: cd serde_test && cargo test --features serde/derive,serde/rc
 
-  beta:
-    name: Rust beta
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: dtolnay/rust-toolchain@beta
-      - run: cd serde && cargo build --features rc
-      - run: cd test_suite && cargo test
-
   nightly:
     name: Rust nightly ${{matrix.os == 'windows' && '(windows)' || ''}}
     runs-on: ${{matrix.os}}-latest
@@ -50,7 +57,7 @@ jobs:
       matrix:
         os: [ubuntu, windows]
     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,12 +66,16 @@ 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
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.13.0
       - name: Get timestamp for cache
         id: date
@@ -85,7 +96,7 @@ jobs:
       matrix:
         rust: [1.19.0, 1.20.0, 1.21.0, 1.25.0, 1.26.0, 1.34.0]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -100,7 +111,7 @@ jobs:
       matrix:
         rust: [1.27.0, 1.28.0]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -113,15 +124,17 @@ jobs:
     name: Rust 1.31.0
     runs-on: ubuntu-latest
     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
       - run: cd serde_derive && cargo check
 
   alloc:
     name: Rust 1.36.0
     runs-on: ubuntu-latest
     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
 
@@ -129,7 +142,7 @@ jobs:
     name: Emscripten
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - uses: actions/setup-node@v1
         with:
@@ -152,12 +165,33 @@ jobs:
     runs-on: ubuntu-latest
     if: github.event_name != 'pull_request'
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@clippy
-        # The need for -Aredundant_field_names here is a Clippy bug.
-        # https://github.com/rust-lang/rust-clippy/issues/5356
-      - run: cd serde && cargo clippy --features rc,unstable -- -D clippy::all -A clippy::redundant_field_names
-      - run: cd serde_derive && cargo clippy -- -D clippy::all
-      - run: cd serde_test && cargo clippy -- -D clippy::all -A clippy::redundant_field_names
-      - run: cd test_suite && cargo clippy --tests --features unstable -- -D clippy::all -A clippy::redundant_field_names
-      - run: cd test_suite/no_std && cargo clippy -- -D clippy::all -A clippy::redundant_field_names
+      - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic -Aclippy::let_underscore_drop
+      - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+      - run: cd serde_derive_internals && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+      - run: cd serde_test && cargo clippy -- -Dclippy::all -Dclippy::pedantic -Aclippy::let_underscore_drop
+      - run: cd test_suite && cargo clippy --tests --features unstable -- -Dclippy::all -Dclippy::pedantic -Aclippy::let_underscore_drop
+      - run: cd test_suite/no_std && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+
+  miri:
+    name: Miri
+    runs-on: ubuntu-latest
+    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'
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1

CONTRIBUTING.md

@@ -31,25 +31,19 @@ tests for you.
 
 ```sh
 # Test all the example code in Serde documentation
-cargo test
-```
-
-##### In the [`test_suite/deps`] directory
-
-```sh
-# This is a prerequisite for running the full test suite
-cargo clean && cargo update && cargo build
+cargo test --features derive
 ```
 
 ##### In the [`test_suite`] directory
 
 ```sh
 # Run the full test suite, including tests of unstable functionality
-cargo test --features unstable
+cargo +nightly test --features unstable
 ```
 
+Note that this test suite currently only supports running on a nightly compiler.
+
 [`serde`]: https://github.com/serde-rs/serde/tree/master/serde
-[`test_suite/deps`]: https://github.com/serde-rs/serde/tree/master/test_suite/deps
 [`test_suite`]: https://github.com/serde-rs/serde/tree/master/test_suite
 
 ## Conduct

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,20 +1,21 @@
 [package]
 name = "serde"
-version = "1.0.120" # remember to update html_root_url and serde_derive dependency
+version = "1.0.145" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-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.120", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.145", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

serde/build.rs

@@ -17,83 +17,96 @@ 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:
     // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
     //
-    // Disabled on Emscripten targets as Emscripten doesn't
-    // currently support integers larger than 64 bits.
-    if minor >= 26 && !emscripten {
-        println!("cargo:rustc-cfg=integer128");
+    // 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=no_integer128");
     }
 
     // Inclusive ranges methods stabilized in Rust 1.27:
     // https://github.com/rust-lang/rust/pull/50758
-    if minor >= 27 {
-        println!("cargo:rustc-cfg=range_inclusive");
+    // 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=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");
     }
 
-    // TryFrom, Atomic types, and non-zero signed integers stabilized in Rust 1.34:
+    // Current minimum supported version of serde_derive crate is Rust 1.31.
+    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");
+    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 src/librustc_target/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");
-        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 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/from_primitive.rs

@@ -1,260 +0,0 @@
-use lib::*;
-
-macro_rules! int_to_int {
-    ($dst:ident, $n:ident) => {
-        if $dst::min_value() as i64 <= $n as i64 && $n as i64 <= $dst::max_value() as i64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-macro_rules! int_to_uint {
-    ($dst:ident, $n:ident) => {
-        if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-macro_rules! uint_to {
-    ($dst:ident, $n:ident) => {
-        if $n as u64 <= $dst::max_value() as u64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-pub trait FromPrimitive: Sized {
-    fn from_i8(n: i8) -> Option<Self>;
-    fn from_i16(n: i16) -> Option<Self>;
-    fn from_i32(n: i32) -> Option<Self>;
-    fn from_i64(n: i64) -> Option<Self>;
-    fn from_u8(n: u8) -> Option<Self>;
-    fn from_u16(n: u16) -> Option<Self>;
-    fn from_u32(n: u32) -> Option<Self>;
-    fn from_u64(n: u64) -> Option<Self>;
-}
-
-macro_rules! impl_from_primitive_for_int {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                uint_to!($t, n)
-            }
-        }
-    };
-}
-
-macro_rules! impl_from_primitive_for_uint {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                uint_to!($t, n)
-            }
-        }
-    };
-}
-
-macro_rules! impl_from_primitive_for_float {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                Some(n as Self)
-            }
-        }
-    };
-}
-
-impl_from_primitive_for_int!(isize);
-impl_from_primitive_for_int!(i8);
-impl_from_primitive_for_int!(i16);
-impl_from_primitive_for_int!(i32);
-impl_from_primitive_for_int!(i64);
-impl_from_primitive_for_uint!(usize);
-impl_from_primitive_for_uint!(u8);
-impl_from_primitive_for_uint!(u16);
-impl_from_primitive_for_uint!(u32);
-impl_from_primitive_for_uint!(u64);
-impl_from_primitive_for_float!(f32);
-impl_from_primitive_for_float!(f64);
-
-serde_if_integer128! {
-    impl FromPrimitive for i128 {
-        #[inline]
-        fn from_i8(n: i8) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i16(n: i16) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i32(n: i32) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u8(n: u8) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u16(n: u16) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u32(n: u32) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Some(n as i128)
-        }
-    }
-
-    impl FromPrimitive for u128 {
-        #[inline]
-        fn from_i8(n: i8) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i16(n: i16) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i32(n: i32) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_u8(n: u8) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u16(n: u16) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u32(n: u32) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Some(n as u128)
-        }
-    }
-}

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,14 +4,13 @@ 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 __private::de::InPlaceSeed;
-use de::from_primitive::FromPrimitive;
+use seed::InPlaceSeed;
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use __private::de::size_hint;
+use __private::size_hint;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -81,39 +80,35 @@ impl<'de> Deserialize<'de> for bool {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-macro_rules! visit_integer_method {
-    ($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
-        #[inline]
-        fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            match FromPrimitive::$from_method(v) {
-                Some(v) => Ok(v),
-                None => Err(Error::invalid_value(
-                    Unexpected::$group(v as $group_ty),
-                    &self,
-                )),
+macro_rules! impl_deserialize_num {
+    ($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)
             }
         }
     };
-}
 
-macro_rules! visit_float_method {
-    ($src_ty:ident, $method:ident) => {
-        #[inline]
-        fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(v as Self::Value)
-        }
-    };
-}
-
-macro_rules! impl_deserialize_num {
-    ($ty:ident, $method:ident, $($visit:ident),*) => {
-        impl<'de> Deserialize<'de> for $ty {
+    ($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
@@ -122,138 +117,312 @@ 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))
                     }
 
-                    $(
-                        impl_deserialize_num!($visit $ty);
-                    )*
+                    $($($method!($val : $visit);)*)*
                 }
 
-                deserializer.$method(PrimitiveVisitor)
+                deserializer.$deserialize(PrimitiveVisitor)
             }
         }
     };
-
-    (integer $ty:ident) => {
-        visit_integer_method!(i8, visit_i8, from_i8, Signed, i64);
-        visit_integer_method!(i16, visit_i16, from_i16, Signed, i64);
-        visit_integer_method!(i32, visit_i32, from_i32, Signed, i64);
-        visit_integer_method!(i64, visit_i64, from_i64, Signed, i64);
-
-        visit_integer_method!(u8, visit_u8, from_u8, Unsigned, u64);
-        visit_integer_method!(u16, visit_u16, from_u16, Unsigned, u64);
-        visit_integer_method!(u32, visit_u32, from_u32, Unsigned, u64);
-        visit_integer_method!(u64, visit_u64, from_u64, Unsigned, u64);
-    };
-
-    (float $ty:ident) => {
-        visit_float_method!(f32, visit_f32);
-        visit_float_method!(f64, visit_f64);
-    };
 }
 
-impl_deserialize_num!(i8, deserialize_i8, integer);
-impl_deserialize_num!(i16, deserialize_i16, integer);
-impl_deserialize_num!(i32, deserialize_i32, integer);
-impl_deserialize_num!(i64, deserialize_i64, integer);
-impl_deserialize_num!(isize, deserialize_i64, integer);
+macro_rules! num_self {
+    ($ty:ident : $visit:ident) => {
+        #[inline]
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(v)
+        }
+    };
 
-impl_deserialize_num!(u8, deserialize_u8, integer);
-impl_deserialize_num!(u16, deserialize_u16, integer);
-impl_deserialize_num!(u32, deserialize_u32, integer);
-impl_deserialize_num!(u64, deserialize_u64, integer);
-impl_deserialize_num!(usize, deserialize_u64, integer);
+    (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))
+            }
+        }
+    };
+}
 
-impl_deserialize_num!(f32, deserialize_f32, integer, float);
-impl_deserialize_num!(f64, deserialize_f64, integer, float);
+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)
+        }
+    };
+
+    (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,
+        {
+            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))
+            }
+        }
+    };
+
+    (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))
+            }
+        }
+    };
+
+    (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))
+            }
+        }
+    };
+
+    (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, 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, 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);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    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);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    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, 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, 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, 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);
+    uint_to_self!(u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    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);
+    uint_to_self!(u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    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, 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);
+}
+
+impl_deserialize_num! {
+    f32, deserialize_f32
+    num_self!(f32:visit_f32);
+    num_as_self!(f64:visit_f64);
+    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);
+}
+
+impl_deserialize_num! {
+    f64, deserialize_f64
+    num_self!(f64:visit_f64);
+    num_as_self!(f32:visit_f32);
+    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);
+}
 
 serde_if_integer128! {
-    impl<'de> Deserialize<'de> for i128 {
-        #[inline]
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct PrimitiveVisitor;
-
-            impl<'de> Visitor<'de> for PrimitiveVisitor {
-                type Value = i128;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("i128")
-                }
-
-                impl_deserialize_num!(integer i128);
-
-                #[inline]
-                fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-                where
-                    E: Error,
+    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)
-                }
-
-                #[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))
-                    }
+                    Ok(v as Self::Value)
+                } else {
+                    Err(Error::invalid_value(
+                        Unexpected::Other(stringify!($ty)),
+                        &self,
+                    ))
                 }
             }
+        };
 
-            deserializer.deserialize_i128(PrimitiveVisitor)
-        }
+        (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<'de> Deserialize<'de> for u128 {
-        #[inline]
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct PrimitiveVisitor;
+    impl_deserialize_num! {
+        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<'de> Visitor<'de> for PrimitiveVisitor {
-                type Value = u128;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("u128")
-                }
-
-                impl_deserialize_num!(integer u128);
-
-                #[inline]
-                fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    if v >= 0 {
-                        Ok(v as u128)
-                    } else {
-                        Err(Error::invalid_value(Unexpected::Other("i128"), &self))
-                    }
-                }
-
-                #[inline]
-                fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    Ok(v)
-                }
-            }
-
-            deserializer.deserialize_u128(PrimitiveVisitor)
-        }
+    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);
+        num_128!(i128:visit_i128);
     }
 }
 
@@ -578,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);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -624,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>,
@@ -1545,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);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1626,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.
     ///
@@ -1642,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.
     ///
@@ -1713,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])*
@@ -1734,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.
     ///
@@ -1746,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.
     ///
@@ -1790,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
@@ -1839,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))
                             }
                         }
                     }
@@ -1849,6 +2021,17 @@ impl<'de> Deserialize<'de> for Duration {
             }
         }
 
+        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
+        where
+            E: Error,
+        {
+            static NANOS_PER_SEC: u32 = 1_000_000_000;
+            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
+                Some(_) => Ok(()),
+                None => Err(E::custom("overflow deserializing Duration")),
+            }
+        }
+
         struct DurationVisitor;
 
         impl<'de> Visitor<'de> for DurationVisitor {
@@ -1874,6 +2057,7 @@ impl<'de> Deserialize<'de> for Duration {
                         return Err(Error::invalid_length(1, &self));
                     }
                 };
+                try!(check_overflow(secs, nanos));
                 Ok(Duration::new(secs, nanos))
             }
 
@@ -1907,6 +2091,7 @@ impl<'de> Deserialize<'de> for Duration {
                     Some(nanos) => nanos,
                     None => return Err(<A::Error as Error>::missing_field("nanos")),
                 };
+                try!(check_overflow(secs, nanos));
                 Ok(Duration::new(secs, nanos))
             }
         }
@@ -1974,6 +2159,17 @@ impl<'de> Deserialize<'de> for SystemTime {
             }
         }
 
+        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
+        where
+            E: Error,
+        {
+            static NANOS_PER_SEC: u32 = 1_000_000_000;
+            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
+                Some(_) => Ok(()),
+                None => Err(E::custom("overflow deserializing SystemTime epoch offset")),
+            }
+        }
+
         struct DurationVisitor;
 
         impl<'de> Visitor<'de> for DurationVisitor {
@@ -1999,6 +2195,7 @@ impl<'de> Deserialize<'de> for SystemTime {
                         return Err(Error::invalid_length(1, &self));
                     }
                 };
+                try!(check_overflow(secs, nanos));
                 Ok(Duration::new(secs, nanos))
             }
 
@@ -2036,13 +2233,20 @@ impl<'de> Deserialize<'de> for SystemTime {
                     Some(nanos) => nanos,
                     None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
                 };
+                try!(check_overflow(secs, nanos));
                 Ok(Duration::new(secs, nanos))
             }
         }
 
         const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
         let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
-        Ok(UNIX_EPOCH + duration)
+        #[cfg(not(no_systemtime_checked_add))]
+        let ret = UNIX_EPOCH
+            .checked_add(duration)
+            .ok_or_else(|| D::Error::custom("overflow deserializing SystemTime"));
+        #[cfg(no_systemtime_checked_add)]
+        let ret = Ok(UNIX_EPOCH + duration);
+        ret
     }
 }
 
@@ -2064,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>,
@@ -2085,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))
     }
 }
@@ -2147,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))
                         }
                     }
                 }
@@ -2228,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>,
@@ -2336,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>,
@@ -2508,7 +2660,7 @@ where
     }
 }
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
     ($($ty:ident)*) => {
         $(
@@ -2524,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,7 +118,8 @@ use lib::*;
 
 pub mod value;
 
-mod from_primitive;
+#[cfg(not(no_integer128))]
+mod format;
 mod ignored_any;
 mod impls;
 mod utf8;
@@ -393,7 +394,7 @@ pub enum Unexpected<'a> {
 }
 
 impl<'a> fmt::Display for Unexpected<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         use self::Unexpected::*;
         match *self {
             Bool(b) => write!(formatter, "boolean `{}`", b),
@@ -564,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(())
     }
 }
@@ -707,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()? {
@@ -868,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
@@ -878,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
@@ -909,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
@@ -1008,7 +1014,7 @@ pub trait Deserializer<'de>: Sized {
     /// `Deserializer`.
     ///
     /// If the `Visitor` would benefit from taking ownership of `String` data,
-    /// indiciate this to the `Deserializer` by using `deserialize_string`
+    /// indicate this to the `Deserializer` by using `deserialize_string`
     /// instead.
     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
@@ -1150,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
@@ -1214,6 +1220,20 @@ pub trait Deserializer<'de>: Sized {
     fn is_human_readable(&self) -> bool {
         true
     }
+
+    // Not public API.
+    #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
+    #[doc(hidden)]
+    fn __deserialize_content<V>(
+        self,
+        _: ::actually_private::T,
+        visitor: V,
+    ) -> Result<::private::de::Content<'de>, Self::Error>
+    where
+        V: Visitor<'de, Value = ::private::de::Content<'de>>,
+    {
+        self.deserialize_any(visitor)
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1353,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))
         }
     }
 
@@ -1413,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))
         }
     }
 
@@ -1536,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`.
@@ -1715,7 +1739,7 @@ pub trait SeqAccess<'de> {
     }
 }
 
-impl<'de, 'a, A> SeqAccess<'de> for &'a mut A
+impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
 where
     A: SeqAccess<'de>,
 {
@@ -1868,7 +1892,7 @@ pub trait MapAccess<'de> {
     }
 }
 
-impl<'de, 'a, A> MapAccess<'de> for &'a mut A
+impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A
 where
     A: MapAccess<'de>,
 {

serde/src/de/seed.rs

@@ -0,0 +1,19 @@
+use de::{Deserialize, DeserializeSeed, Deserializer};
+
+/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
+///
+/// Wraps a mutable reference and calls deserialize_in_place on it.
+pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
+
+impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
+where
+    T: Deserialize<'de>,
+{
+    type Value = ();
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        T::deserialize_in_place(deserializer, self.0)
+    }
+}

serde/src/de/value.rs

@@ -24,8 +24,8 @@
 use lib::*;
 
 use self::private::{First, Second};
-use __private::de::size_hint;
-use de::{self, Expected, IntoDeserializer, SeqAccess};
+use __private::size_hint;
+use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor};
 use ser;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -48,7 +48,7 @@ macro_rules! impl_copy_clone {
 
 /// A minimal representation of all possible errors that can occur using the
 /// `IntoDeserializer` trait.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub struct Error {
     err: ErrorImpl,
 }
@@ -93,16 +93,25 @@ impl ser::Error for Error {
 
 impl Display for Error {
     #[cfg(any(feature = "std", feature = "alloc"))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         formatter.write_str(&self.err)
     }
 
     #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         formatter.write_str("Serde deserialization error")
     }
 }
 
+impl Debug for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = formatter.debug_tuple("Error");
+        #[cfg(any(feature = "std", feature = "alloc"))]
+        debug.field(&self.err);
+        debug.finish()
+    }
+}
+
 #[cfg(feature = "std")]
 impl error::Error for Error {
     fn description(&self) -> &str {
@@ -119,20 +128,26 @@ where
     type Deserializer = UnitDeserializer<E>;
 
     fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer {
-            marker: PhantomData,
-        }
+        UnitDeserializer::new()
     }
 }
 
 /// A deserializer holding a `()`.
-#[derive(Debug)]
 pub struct UnitDeserializer<E> {
     marker: PhantomData<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,
@@ -160,6 +175,12 @@ where
     }
 }
 
+impl<E> Debug for UnitDeserializer<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.debug_struct("UnitDeserializer").finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer that cannot be instantiated.
@@ -208,7 +229,6 @@ macro_rules! primitive_deserializer {
     ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
         #[doc = "A deserializer holding"]
         #[doc = $doc]
-        #[derive(Debug)]
         pub struct $name<E> {
             value: $ty,
             marker: PhantomData<E>
@@ -223,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,
                 }
             }
@@ -249,6 +276,15 @@ macro_rules! primitive_deserializer {
                 visitor.$method(self.value $($cast)*)
             }
         }
+
+        impl<E> Debug for $name<E> {
+            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter
+                    .debug_struct(stringify!($name))
+                    .field("value", &self.value)
+                    .finish()
+            }
+        }
     }
 }
 
@@ -272,7 +308,6 @@ serde_if_integer128! {
 }
 
 /// A deserializer holding a `u32`.
-#[derive(Debug)]
 pub struct U32Deserializer<E> {
     value: u32,
     marker: PhantomData<E>,
@@ -287,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,
         }
     }
@@ -343,10 +385,18 @@ where
     }
 }
 
+impl<E> Debug for U32Deserializer<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("U32Deserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `&str`.
-#[derive(Debug)]
 pub struct StrDeserializer<'a, E> {
     value: &'a str,
     marker: PhantomData<E>,
@@ -361,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,
         }
     }
@@ -417,11 +474,19 @@ where
     }
 }
 
+impl<'a, E> Debug for StrDeserializer<'a, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("StrDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `&str` with a lifetime tied to another
 /// deserializer.
-#[derive(Debug)]
 pub struct BorrowedStrDeserializer<'de, E> {
     value: &'de str,
     marker: PhantomData<E>,
@@ -488,11 +553,19 @@ where
     }
 }
 
+impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("BorrowedStrDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `String`.
 #[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Debug)]
 pub struct StringDeserializer<E> {
     value: String,
     marker: PhantomData<E>,
@@ -516,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,
         }
     }
@@ -559,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,
 {
@@ -574,11 +655,20 @@ where
     }
 }
 
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> Debug for StringDeserializer<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("StringDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `Cow<str>`.
 #[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Debug)]
 pub struct CowStrDeserializer<'a, E> {
     value: Cow<'a, str>,
     marker: PhantomData<E>,
@@ -602,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,
         }
     }
@@ -663,29 +761,48 @@ where
     }
 }
 
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> Debug for CowStrDeserializer<'a, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("CowStrDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
-/// A deserializer holding a `&[u8]` with a lifetime tied to another
-/// deserializer.
-#[derive(Debug)]
-pub struct BorrowedBytesDeserializer<'de, E> {
-    value: &'de [u8],
+/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
+pub struct BytesDeserializer<'a, E> {
+    value: &'a [u8],
     marker: PhantomData<E>,
 }
 
-impl_copy_clone!(BorrowedBytesDeserializer<'de>);
-
-impl<'de, E> BorrowedBytesDeserializer<'de, E> {
-    /// Create a new borrowed deserializer from the given byte slice.
-    pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> {
-        BorrowedBytesDeserializer {
+impl<'a, E> BytesDeserializer<'a, E> {
+    /// Create a new deserializer from the given bytes.
+    pub fn new(value: &'a [u8]) -> Self {
+        BytesDeserializer {
             value: value,
             marker: PhantomData,
         }
     }
 }
 
-impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
+impl_copy_clone!(BytesDeserializer<'a>);
+
+impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8]
+where
+    E: de::Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+
+    fn into_deserializer(self) -> BytesDeserializer<'a, E> {
+        BytesDeserializer::new(self)
+    }
+}
+
+impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
 where
     E: de::Error,
 {
@@ -693,7 +810,55 @@ where
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
-        V: de::Visitor<'de>,
+        V: Visitor<'de>,
+    {
+        visitor.visit_bytes(self.value)
+    }
+
+    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
+    }
+}
+
+impl<'a, E> Debug for BytesDeserializer<'a, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("BytesDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
+/// A deserializer holding a `&[u8]` with a lifetime tied to another
+/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
+pub struct BorrowedBytesDeserializer<'de, E> {
+    value: &'de [u8],
+    marker: PhantomData<E>,
+}
+
+impl<'de, E> BorrowedBytesDeserializer<'de, E> {
+    /// Create a new borrowed deserializer from the given borrowed bytes.
+    pub fn new(value: &'de [u8]) -> Self {
+        BorrowedBytesDeserializer {
+            value: value,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl_copy_clone!(BorrowedBytesDeserializer<'de>);
+
+impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
+where
+    E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
     {
         visitor.visit_borrowed_bytes(self.value)
     }
@@ -701,14 +866,23 @@ where
     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 identifier ignored_any enum
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("BorrowedBytesDeserializer")
+            .field("value", &self.value)
+            .finish()
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer that iterates over a sequence.
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct SeqDeserializer<I, E> {
     iter: iter::Fuse<I>,
     count: usize,
@@ -813,6 +987,19 @@ impl Expected for ExpectedInSeq {
     }
 }
 
+impl<I, E> Debug for SeqDeserializer<I, E>
+where
+    I: Debug,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("SeqDeserializer")
+            .field("iter", &self.iter)
+            .field("count", &self.count)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -1108,7 +1295,6 @@ where
     }
 }
 
-// Cannot #[derive(Debug)] because of the bound `Second<I::Item>: Debug`.
 impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
 where
     I: Iterator + Debug,
@@ -1121,8 +1307,6 @@ where
             .field("iter", &self.iter)
             .field("value", &self.value)
             .field("count", &self.count)
-            .field("lifetime", &self.lifetime)
-            .field("error", &self.error)
             .finish()
     }
 }
@@ -1317,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")),
         }
@@ -1331,7 +1515,6 @@ mod private {
 
     use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};
 
-    #[derive(Clone, Debug)]
     pub struct UnitOnly<E> {
         marker: PhantomData<E>,
     }
@@ -1390,7 +1573,6 @@ mod private {
         }
     }
 
-    #[derive(Clone, Debug)]
     pub struct MapAsEnum<A> {
         map: A,
     }

serde/src/integer128.rs

@@ -10,7 +10,7 @@
 /// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
-/// # use serde::__private::ser::Error;
+/// # use serde::__private::doc::Error;
 /// #
 /// # struct MySerializer;
 /// #
@@ -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
@@ -44,8 +43,7 @@
 //! - [BSON], the data storage and network transfer format used by MongoDB.
 //! - [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.
+//! - [JSON5], a superset of JSON including some productions from ES5.
 //! - [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
-//! [CBOR]: https://github.com/pyfisch/cbor
+//! [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
 //! [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]: http://doc.crates.io/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
+//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.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.120")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.145")]
 // 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
@@ -94,18 +91,17 @@
 #![cfg_attr(feature = "unstable", feature(never_type))]
 #![allow(unknown_lints, bare_trait_objects, deprecated)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy and clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
         // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
         unnested_or_patterns,
+        // 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,
@@ -119,8 +115,12 @@
         use_self,
         zero_prefixed_literal,
         // correctly used
+        derive_partial_eq_without_eq,
         enum_glob_use,
+        explicit_auto_deref,
+        let_underscore_drop,
         map_err_ignore,
+        new_without_default,
         result_unit_err,
         wildcard_imports,
         // not practical
@@ -138,7 +138,6 @@
     )
 )]
 // Rustc lints.
-#![forbid(unsafe_code)]
 #![deny(missing_docs, unused_imports)]
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -157,7 +156,7 @@ mod lib {
         pub use std::*;
     }
 
-    pub use self::core::{cmp, iter, mem, num, slice, str};
+    pub use self::core::{cmp, iter, mem, num, ptr, slice, str};
     pub use self::core::{f32, f64};
     pub use self::core::{i16, i32, i64, i8, isize};
     pub use self::core::{u16, u32, u64, u8, usize};
@@ -226,30 +225,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]
@@ -276,6 +288,9 @@ use self::__private as export;
 #[allow(unused_imports)]
 use self::__private as private;
 
+#[path = "de/seed.rs"]
+mod seed;
+
 #[cfg(not(feature = "std"))]
 mod std_error;
 
@@ -291,3 +306,8 @@ extern crate serde_derive;
 #[cfg(feature = "serde_derive")]
 #[doc(hidden)]
 pub use serde_derive::*;
+
+#[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
+mod actually_private {
+    pub struct T;
+}

serde/src/private/de.rs

@@ -1,9 +1,10 @@
 use lib::*;
 
-use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
+use de::value::{BorrowedBytesDeserializer, BytesDeserializer};
+use de::{Deserialize, Deserializer, Error, IntoDeserializer, Visitor};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use de::{MapAccess, Unexpected};
+use de::{DeserializeSeed, MapAccess, Unexpected};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub use self::content::{
@@ -12,6 +13,8 @@ pub use self::content::{
     TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
 };
 
+pub use seed::InPlaceSeed;
+
 /// If the missing field is of type `Option<T>` then treat is as `None`,
 /// otherwise it is an error.
 pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
@@ -188,29 +191,6 @@ where
         .map(From::from)
 }
 
-pub mod size_hint {
-    use lib::*;
-
-    pub fn from_bounds<I>(iter: &I) -> Option<usize>
-    where
-        I: Iterator,
-    {
-        helper(iter.size_hint())
-    }
-
-    #[inline]
-    pub fn cautious(hint: Option<usize>) -> usize {
-        cmp::min(hint.unwrap_or(0), 4096)
-    }
-
-    fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
-        match bounds {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 mod content {
     // This module is private and nothing here should be used outside of
@@ -225,7 +205,8 @@ mod content {
 
     use lib::*;
 
-    use super::size_hint;
+    use __private::size_hint;
+    use actually_private;
     use de::{
         self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
         MapAccess, SeqAccess, Unexpected, Visitor,
@@ -235,7 +216,7 @@ mod content {
     /// deserializing untagged enums and internally tagged enums.
     ///
     /// Not public API. Use serde-value instead.
-    #[derive(Debug)]
+    #[derive(Debug, Clone)]
     pub enum Content<'de> {
         Bool(bool),
 
@@ -314,7 +295,7 @@ mod content {
             // Untagged and internally tagged enums are only supported in
             // self-describing formats.
             let visitor = ContentVisitor { value: PhantomData };
-            deserializer.deserialize_any(visitor)
+            deserializer.__deserialize_content(actually_private::T, visitor)
         }
     }
 
@@ -824,15 +805,17 @@ mod content {
     /// Not public API.
     pub struct TaggedContentVisitor<'de, T> {
         tag_name: &'static str,
+        expecting: &'static str,
         value: PhantomData<TaggedContent<'de, T>>,
     }
 
     impl<'de, T> TaggedContentVisitor<'de, T> {
         /// Visitor for the content of an internally tagged enum with the given
         /// tag name.
-        pub fn new(name: &'static str) -> Self {
+        pub fn new(name: &'static str, expecting: &'static str) -> Self {
             TaggedContentVisitor {
                 tag_name: name,
+                expecting: expecting,
                 value: PhantomData,
             }
         }
@@ -861,7 +844,7 @@ mod content {
         type Value = TaggedContent<'de, T>;
 
         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            fmt.write_str("internally tagged enum")
+            fmt.write_str(self.expecting)
         }
 
         fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
@@ -1040,6 +1023,25 @@ mod content {
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
+
+        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
     }
 
     fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E>
@@ -1179,25 +1181,14 @@ mod content {
         where
             V: Visitor<'de>,
         {
-            match self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
         }
 
         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where
             V: Visitor<'de>,
         {
-            match self.content {
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
         }
 
         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -1297,8 +1288,9 @@ mod content {
                 //     }
                 //
                 // We want {"topic":"Info"} to deserialize even though
-                // ordinarily unit structs do not deserialize from empty map.
+                // ordinarily unit structs do not deserialize from empty map/seq.
                 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
+                Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(),
                 _ => self.deserialize_any(visitor),
             }
         }
@@ -1436,6 +1428,18 @@ mod content {
             drop(self);
             visitor.visit_unit()
         }
+
+        fn __deserialize_content<V>(
+            self,
+            _: actually_private::T,
+            visitor: V,
+        ) -> Result<Content<'de>, Self::Error>
+        where
+            V: Visitor<'de, Value = Content<'de>>,
+        {
+            let _ = visitor;
+            Ok(self.content)
+        }
     }
 
     impl<'de, E> ContentDeserializer<'de, E> {
@@ -1751,6 +1755,25 @@ mod content {
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
+
+        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
     }
 
     fn visit_content_seq_ref<'a, 'de, V, E>(
@@ -1898,25 +1921,14 @@ mod content {
         where
             V: Visitor<'de>,
         {
-            match *self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
         }
 
         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where
             V: Visitor<'de>,
         {
-            match *self.content {
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
         }
 
         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -2139,6 +2151,18 @@ mod content {
         {
             visitor.visit_unit()
         }
+
+        fn __deserialize_content<V>(
+            self,
+            _: actually_private::T,
+            visitor: V,
+        ) -> Result<Content<'de>, Self::Error>
+        where
+            V: Visitor<'de, Value = Content<'de>>,
+        {
+            let _ = visitor;
+            Ok(self.content.clone())
+        }
     }
 
     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
@@ -2542,11 +2566,13 @@ pub trait IdentifierDeserializer<'de, E: Error> {
     fn from(self) -> Self::Deserializer;
 }
 
-impl<'de, E> IdentifierDeserializer<'de, E> for u32
+pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
+
+impl<'de, E> IdentifierDeserializer<'de, E> for u64
 where
     E: Error,
 {
-    type Deserializer = <u32 as IntoDeserializer<'de, E>>::Deserializer;
+    type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
 
     fn from(self) -> Self::Deserializer {
         self.into_deserializer()
@@ -2558,20 +2584,6 @@ pub struct StrDeserializer<'a, E> {
     marker: PhantomData<E>,
 }
 
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
-where
-    E: Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        StrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
 where
     E: Error,
@@ -2592,26 +2604,12 @@ where
     }
 }
 
-pub struct BytesDeserializer<'a, E> {
-    value: &'a [u8],
+pub struct BorrowedStrDeserializer<'de, E> {
+    value: &'de str,
     marker: PhantomData<E>,
 }
 
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
-where
-    E: Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BytesDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
+impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
 where
     E: Error,
 {
@@ -2621,7 +2619,7 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_bytes(self.value)
+        visitor.visit_borrowed_str(self.value)
     }
 
     forward_to_deserialize_any! {
@@ -2631,21 +2629,53 @@ where
     }
 }
 
-/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
-///
-/// Wraps a mutable reference and calls deserialize_in_place on it.
-pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
-
-impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
 where
-    T: Deserialize<'de>,
+    E: Error,
 {
-    type Value = ();
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize_in_place(deserializer, self.0)
+    type Deserializer = StrDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        StrDeserializer {
+            value: self,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedStrDeserializer<'de, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BorrowedStrDeserializer {
+            value: self.0,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
+where
+    E: Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BytesDeserializer::new(self)
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedBytesDeserializer<'de, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BorrowedBytesDeserializer::new(self.0)
     }
 }
 
@@ -2827,7 +2857,7 @@ where
     where
         T: DeserializeSeed<'de>,
     {
-        while let Some(item) = self.iter.next() {
+        for item in &mut self.iter {
             // Items in the vector are nulled out when used by a struct.
             if let Some((ref key, ref content)) = *item {
                 self.pending_content = Some(content);
@@ -2929,7 +2959,7 @@ where
     where
         T: DeserializeSeed<'de>,
     {
-        while let Some(item) = self.iter.next() {
+        for item in &mut self.iter {
             if let Some((ref key, ref content)) = *item {
                 // Do not take(), instead borrow this entry. The internally tagged
                 // enum does its own buffering so we can't tell whether this entry

serde/src/private/doc.rs

@@ -1,3 +1,35 @@
+// Used only by Serde doc tests. Not public API.
+
+use lib::*;
+
+use ser;
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct Error;
+
+impl ser::Error for Error {
+    fn custom<T>(_: T) -> Self
+    where
+        T: Display,
+    {
+        unimplemented!()
+    }
+}
+
+#[cfg(feature = "std")]
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        unimplemented!()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+        unimplemented!()
+    }
+}
+
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __private_serialize {
@@ -10,19 +42,6 @@ macro_rules! __private_serialize {
     };
 }
 
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __private_deserialize {
-    () => {
-        trait Deserialize<'de>: Sized {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: $crate::Deserializer<'de>;
-        }
-    };
-}
-
-/// Used only by Serde doc tests. Not public API.
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
 macro_rules! __serialize_unimplemented {

serde/src/private/mod.rs

@@ -1,14 +1,20 @@
-mod macros;
-
+#[cfg(not(no_serde_derive))]
 pub mod de;
+#[cfg(not(no_serde_derive))]
 pub mod ser;
 
+pub mod size_hint;
+
+// FIXME: #[cfg(doctest)] once https://github.com/rust-lang/rust/issues/67295 is fixed.
+pub mod doc;
+
 pub use lib::clone::Clone;
 pub use lib::convert::{From, Into};
 pub use lib::default::Default;
 pub use lib::fmt::{self, Formatter};
 pub use lib::marker::PhantomData;
 pub use lib::option::Option::{self, None, Some};
+pub use lib::ptr;
 pub use lib::result::Result::{self, Err, Ok};
 
 pub use self::string::from_utf8_lossy;
@@ -16,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

@@ -335,33 +335,6 @@ where
     }
 }
 
-/// Used only by Serde doc tests. Not public API.
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Error;
-
-impl ser::Error for Error {
-    fn custom<T>(_: T) -> Self
-    where
-        T: Display,
-    {
-        unimplemented!()
-    }
-}
-
-#[cfg(feature = "std")]
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        unimplemented!()
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        unimplemented!()
-    }
-}
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 mod content {
     use lib::*;
@@ -452,7 +425,6 @@ mod content {
         }
     }
 
-    #[derive(Debug)]
     pub enum Content {
         Bool(bool),
 

serde/src/private/size_hint.rs

@@ -0,0 +1,21 @@
+use lib::*;
+
+pub fn from_bounds<I>(iter: &I) -> Option<usize>
+where
+    I: Iterator,
+{
+    helper(iter.size_hint())
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+#[inline]
+pub fn cautious(hint: Option<usize>) -> usize {
+    cmp::min(hint.unwrap_or(0), 4096)
+}
+
+fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
+    match bounds {
+        (lower, Some(upper)) if lower == upper => Some(upper),
+        _ => None,
+    }
+}

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()));
@@ -674,6 +675,52 @@ impl Serialize for net::IpAddr {
     }
 }
 
+#[cfg(feature = "std")]
+const DEC_DIGITS_LUT: &'static [u8] = b"\
+      0001020304050607080910111213141516171819\
+      2021222324252627282930313233343536373839\
+      4041424344454647484950515253545556575859\
+      6061626364656667686970717273747576777879\
+      8081828384858687888990919293949596979899";
+
+#[cfg(feature = "std")]
+#[inline]
+fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
+    if n >= 100 {
+        let d1 = ((n % 100) << 1) as usize;
+        n /= 100;
+        out[0] = b'0' + n;
+        out[1] = DEC_DIGITS_LUT[d1];
+        out[2] = DEC_DIGITS_LUT[d1 + 1];
+        3
+    } else if n >= 10 {
+        let d1 = (n << 1) as usize;
+        out[0] = DEC_DIGITS_LUT[d1];
+        out[1] = DEC_DIGITS_LUT[d1 + 1];
+        2
+    } else {
+        out[0] = b'0' + n;
+        1
+    }
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn test_format_u8() {
+    let mut i = 0u8;
+
+    loop {
+        let mut buf = [0u8; 3];
+        let written = format_u8(i, &mut buf);
+        assert_eq!(i.to_string().as_bytes(), &buf[..written]);
+
+        match i.checked_add(1) {
+            Some(next) => i = next,
+            None => break,
+        }
+    }
+}
+
 #[cfg(feature = "std")]
 impl Serialize for net::Ipv4Addr {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -683,7 +730,14 @@ impl Serialize for net::Ipv4Addr {
         if serializer.is_human_readable() {
             const MAX_LEN: usize = 15;
             debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+            let mut buf = [b'.'; MAX_LEN];
+            let mut written = format_u8(self.octets()[0], &mut buf);
+            for oct in &self.octets()[1..] {
+                // 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]) })
         } else {
             self.octets().serialize(serializer)
         }
@@ -837,7 +891,7 @@ where
     }
 }
 
-#[cfg(core_reverse)]
+#[cfg(not(no_core_reverse))]
 impl<T> Serialize for Reverse<T>
 where
     T: Serialize,
@@ -853,7 +907,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
     ($($ty:ident)*) => {
         $(
@@ -862,21 +916,22 @@ macro_rules! atomic_impl {
                 where
                     S: Serializer,
                 {
-                    self.load(Ordering::SeqCst).serialize(serializer)
+                    // Matches the atomic ordering used in libcore for the Debug impl
+                    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/impossible.rs

@@ -17,7 +17,7 @@ use ser::{
 ///
 /// ```edition2018
 /// # use serde::ser::{Serializer, Impossible};
-/// # use serde::__private::ser::Error;
+/// # use serde::__private::doc::Error;
 /// #
 /// # struct MySerializer;
 /// #

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
@@ -711,7 +711,7 @@ pub trait Serializer: Sized {
     ///
     /// ```edition2018
     /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::__private::ser::Error;
+    /// # use serde::__private::doc::Error;
     /// #
     /// # struct MySerializer;
     /// #
@@ -1279,9 +1279,20 @@ pub trait Serializer: Sized {
     {
         let iter = iter.into_iter();
         let mut serializer = try!(self.serialize_seq(iterator_len_hint(&iter)));
-        for item in iter {
-            try!(serializer.serialize_element(&item));
+
+        #[cfg(not(no_iterator_try_fold))]
+        {
+            let mut iter = iter;
+            try!(iter.try_for_each(|item| serializer.serialize_element(&item)));
         }
+
+        #[cfg(no_iterator_try_fold)]
+        {
+            for item in iter {
+                try!(serializer.serialize_element(&item));
+            }
+        }
+
         serializer.end()
     }
 
@@ -1319,9 +1330,20 @@ pub trait Serializer: Sized {
     {
         let iter = iter.into_iter();
         let mut serializer = try!(self.serialize_map(iterator_len_hint(&iter)));
-        for (key, value) in iter {
-            try!(serializer.serialize_entry(&key, &value));
+
+        #[cfg(not(no_iterator_try_fold))]
+        {
+            let mut iter = iter;
+            try!(iter.try_for_each(|(key, value)| serializer.serialize_entry(&key, &value)));
         }
+
+        #[cfg(no_iterator_try_fold)]
+        {
+            for (key, value) in iter {
+                try!(serializer.serialize_entry(&key, &value));
+            }
+        }
+
         serializer.end()
     }
 
@@ -1401,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,15 +1,17 @@
 [package]
 name = "serde_derive"
-version = "1.0.120" # remember to update html_root_url
+version = "1.0.145" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-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 = []
@@ -22,7 +24,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.58", features = ["visit"] }
+syn = "1.0.90"
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/build.rs

@@ -13,8 +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=no_ptr_addr_of");
     }
 }
 

serde_derive/src/bound.rs

@@ -2,7 +2,6 @@ use std::collections::HashSet;
 
 use syn;
 use syn::punctuated::{Pair, Punctuated};
-use syn::visit::{self, Visit};
 
 use internals::ast::{Container, Data};
 use internals::{attr, ungroup};
@@ -50,8 +49,8 @@ pub fn with_where_predicates_from_fields(
     let predicates = cont
         .data
         .all_fields()
-        .flat_map(|field| from_field(&field.attrs))
-        .flat_map(|predicates| predicates.to_vec());
+        .filter_map(|field| from_field(&field.attrs))
+        .flat_map(<[syn::WherePredicate]>::to_vec);
 
     let mut generics = generics.clone();
     generics.make_where_clause().predicates.extend(predicates);
@@ -72,8 +71,8 @@ pub fn with_where_predicates_from_variants(
 
     let predicates = variants
         .iter()
-        .flat_map(|variant| from_variant(&variant.attrs))
-        .flat_map(|predicates| predicates.to_vec());
+        .filter_map(|variant| from_variant(&variant.attrs))
+        .flat_map(<[syn::WherePredicate]>::to_vec);
 
     let mut generics = generics.clone();
     generics.make_where_clause().predicates.extend(predicates);
@@ -112,7 +111,8 @@ pub fn with_bound(
         // parameters.
         associated_type_usage: Vec<&'ast syn::TypePath>,
     }
-    impl<'ast> Visit<'ast> for FindTyParams<'ast> {
+
+    impl<'ast> FindTyParams<'ast> {
         fn visit_field(&mut self, field: &'ast syn::Field) {
             if let syn::Type::Path(ty) = ungroup(&field.ty) {
                 if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
@@ -138,7 +138,96 @@ pub fn with_bound(
                     self.relevant_type_params.insert(id.clone());
                 }
             }
-            visit::visit_path(self, path);
+            for segment in &path.segments {
+                self.visit_path_segment(segment);
+            }
+        }
+
+        // Everything below is simply traversing the syntax tree.
+
+        fn visit_type(&mut self, ty: &'ast syn::Type) {
+            match ty {
+                syn::Type::Array(ty) => self.visit_type(&ty.elem),
+                syn::Type::BareFn(ty) => {
+                    for arg in &ty.inputs {
+                        self.visit_type(&arg.ty);
+                    }
+                    self.visit_return_type(&ty.output);
+                }
+                syn::Type::Group(ty) => self.visit_type(&ty.elem),
+                syn::Type::ImplTrait(ty) => {
+                    for bound in &ty.bounds {
+                        self.visit_type_param_bound(bound);
+                    }
+                }
+                syn::Type::Macro(ty) => self.visit_macro(&ty.mac),
+                syn::Type::Paren(ty) => self.visit_type(&ty.elem),
+                syn::Type::Path(ty) => {
+                    if let Some(qself) = &ty.qself {
+                        self.visit_type(&qself.ty);
+                    }
+                    self.visit_path(&ty.path);
+                }
+                syn::Type::Ptr(ty) => self.visit_type(&ty.elem),
+                syn::Type::Reference(ty) => self.visit_type(&ty.elem),
+                syn::Type::Slice(ty) => self.visit_type(&ty.elem),
+                syn::Type::TraitObject(ty) => {
+                    for bound in &ty.bounds {
+                        self.visit_type_param_bound(bound);
+                    }
+                }
+                syn::Type::Tuple(ty) => {
+                    for elem in &ty.elems {
+                        self.visit_type(elem);
+                    }
+                }
+
+                syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
+
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                _ => {}
+            }
+        }
+
+        fn visit_path_segment(&mut self, segment: &'ast syn::PathSegment) {
+            self.visit_path_arguments(&segment.arguments);
+        }
+
+        fn visit_path_arguments(&mut self, arguments: &'ast syn::PathArguments) {
+            match arguments {
+                syn::PathArguments::None => {}
+                syn::PathArguments::AngleBracketed(arguments) => {
+                    for arg in &arguments.args {
+                        match arg {
+                            syn::GenericArgument::Type(arg) => self.visit_type(arg),
+                            syn::GenericArgument::Binding(arg) => self.visit_type(&arg.ty),
+                            syn::GenericArgument::Lifetime(_)
+                            | syn::GenericArgument::Constraint(_)
+                            | syn::GenericArgument::Const(_) => {}
+                        }
+                    }
+                }
+                syn::PathArguments::Parenthesized(arguments) => {
+                    for argument in &arguments.inputs {
+                        self.visit_type(argument);
+                    }
+                    self.visit_return_type(&arguments.output);
+                }
+            }
+        }
+
+        fn visit_return_type(&mut self, return_type: &'ast syn::ReturnType) {
+            match return_type {
+                syn::ReturnType::Default => {}
+                syn::ReturnType::Type(_, output) => self.visit_type(output),
+            }
+        }
+
+        fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
+            match bound {
+                syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
+                syn::TypeParamBound::Lifetime(_) => {}
+            }
         }
 
         // Type parameter should not be considered used by a macro path.

serde_derive/src/de.rs

@@ -8,13 +8,17 @@ use bound;
 use dummy;
 use fragment::{Expr, Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, ungroup, Ctxt, Derive};
+use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
 use pretend;
 
 use std::collections::BTreeSet;
 use std::ptr;
 
-pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_deserialize(
+    input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+    replace_receiver(input);
+
     let ctxt = Ctxt::new();
     let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
         Some(cont) => cont,
@@ -32,7 +36,7 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;
-        let used = pretend::pretend_used(&cont);
+        let used = pretend::pretend_used(&cont, params.is_packed);
         quote! {
             impl #de_impl_generics #ident #ty_generics #where_clause {
                 #vis fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<#remote #ty_generics, __D::Error>
@@ -121,6 +125,9 @@ struct Parameters {
     /// At least one field has a serde(getter) attribute, implying that the
     /// remote type has a private field.
     has_getter: bool,
+
+    /// Type has a repr(packed) attribute.
+    is_packed: bool,
 }
 
 impl Parameters {
@@ -133,6 +140,7 @@ impl Parameters {
         let borrowed = borrowed_lifetimes(cont);
         let generics = build_generics(cont, &borrowed);
         let has_getter = cont.data.has_getter();
+        let is_packed = cont.attrs.is_packed();
 
         Parameters {
             local,
@@ -140,6 +148,7 @@ impl Parameters {
             generics,
             borrowed,
             has_getter,
+            is_packed,
         }
     }
 
@@ -402,6 +411,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
     let type_name = cattrs.name().deserialize_name();
 
     let expecting = format!("unit struct {}", params.type_name());
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     quote_block! {
         struct __Visitor;
@@ -459,6 +469,7 @@ fn deserialize_tuple(
         Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
         None => format!("tuple struct {}", params.type_name()),
     };
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     let nfields = fields.len();
 
@@ -469,7 +480,7 @@ fn deserialize_tuple(
     };
 
     let visit_seq = Stmts(deserialize_seq(
-        &type_path, params, fields, false, cattrs, &expecting,
+        &type_path, params, fields, false, cattrs, expecting,
     ));
 
     let visitor_expr = quote! {
@@ -545,6 +556,7 @@ fn deserialize_tuple_in_place(
         Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
         None => format!("tuple struct {}", params.type_name()),
     };
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     let nfields = fields.len();
 
@@ -554,7 +566,7 @@ fn deserialize_tuple_in_place(
         None
     };
 
-    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, &expecting));
+    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting));
 
     let visitor_expr = quote! {
         __Visitor {
@@ -633,6 +645,7 @@ fn deserialize_seq(
     } else {
         format!("{} with {} elements", expecting, deserialized_count)
     };
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     let mut index_in_seq = 0_usize;
     let let_values = vars.clone().zip(fields).map(|(var, field)| {
@@ -735,6 +748,7 @@ fn deserialize_seq_in_place(
     } else {
         format!("{} with {} elements", expecting, deserialized_count)
     };
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     let mut index_in_seq = 0usize;
     let write_values = fields.iter().map(|field| {
@@ -910,9 +924,10 @@ fn deserialize_struct(
         Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
         None => format!("struct {}", params.type_name()),
     };
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     let visit_seq = Stmts(deserialize_seq(
-        &type_path, params, fields, true, cattrs, &expecting,
+        &type_path, params, fields, true, cattrs, expecting,
     ));
 
     let (field_visitor, fields_stmt, visit_map) = if cattrs.has_flatten() {
@@ -1051,8 +1066,9 @@ fn deserialize_struct_in_place(
         Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
         None => format!("struct {}", params.type_name()),
     };
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
-    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, &expecting));
+    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting));
 
     let (field_visitor, fields_stmt, visit_map) =
         deserialize_struct_as_struct_in_place_visitor(params, fields, cattrs);
@@ -1203,6 +1219,7 @@ fn deserialize_externally_tagged_enum(
 
     let type_name = cattrs.name().deserialize_name();
     let expecting = format!("enum {}", params.type_name());
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
 
@@ -1312,6 +1329,9 @@ fn deserialize_internally_tagged_enum(
             }
         });
 
+    let expecting = format!("internally tagged enum {}", params.type_name());
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
+
     quote_block! {
         #variant_visitor
 
@@ -1319,7 +1339,7 @@ fn deserialize_internally_tagged_enum(
 
         let __tagged = try!(_serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag)));
+            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting)));
 
         match __tagged.tag {
             #(#variant_arms)*
@@ -1362,6 +1382,7 @@ fn deserialize_adjacently_tagged_enum(
         .collect();
 
     let expecting = format!("adjacently tagged enum {}", params.type_name());
+    let expecting = cattrs.expecting().unwrap_or(&expecting);
     let type_name = cattrs.name().deserialize_name();
     let deny_unknown_fields = cattrs.deny_unknown_fields();
 
@@ -1437,7 +1458,7 @@ fn deserialize_adjacently_tagged_enum(
             while let _serde::__private::Some(__k) = #next_key {
                 match __k {
                     _serde::__private::de::TagContentOtherField::Other => {
-                        try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
+                        let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
                         continue;
                     },
                     _serde::__private::de::TagContentOtherField::Tag => {
@@ -1653,6 +1674,7 @@ fn deserialize_untagged_enum(
         "data did not match any variant of untagged enum {}",
         params.type_name()
     );
+    let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
 
     quote_block! {
         let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
@@ -1711,6 +1733,8 @@ fn deserialize_externally_tagged_variant(
     }
 }
 
+// Generates significant part of the visit_seq and visit_map bodies of visitors
+// for the variants of internally tagged enum.
 fn deserialize_internally_tagged_variant(
     params: &Parameters,
     variant: &Variant,
@@ -1762,11 +1786,9 @@ fn deserialize_untagged_variant(
     deserializer: TokenStream,
 ) -> Fragment {
     if let Some(path) = variant.attrs.deserialize_with() {
-        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
+        let unwrap_fn = unwrap_to_variant_closure(params, variant, false);
         return quote_block! {
-            #wrapper
-            _serde::__private::Result::map(
-                <#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer), #unwrap_fn)
+            _serde::__private::Result::map(#path(#deserializer), #unwrap_fn)
         };
     }
 
@@ -1909,7 +1931,9 @@ fn deserialize_generated_identifier(
         fields,
         is_variant,
         fallthrough,
+        None,
         !is_variant && cattrs.has_flatten(),
+        None,
     ));
 
     let lifetime = if !is_variant && cattrs.has_flatten() {
@@ -1945,6 +1969,8 @@ fn deserialize_generated_identifier(
     }
 }
 
+// Generates `Deserialize::deserialize` body for an enum with
+// `serde(field_identifier)` or `serde(variant_identifier)` attribute.
 fn deserialize_custom_identifier(
     params: &Parameters,
     variants: &[Variant],
@@ -1959,26 +1985,38 @@ fn deserialize_custom_identifier(
     let this = &params.this;
     let this = quote!(#this);
 
-    let (ordinary, fallthrough) = if let Some(last) = variants.last() {
+    let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
         let last_ident = &last.ident;
         if last.attrs.other() {
+            // Process `serde(other)` attribute. It would always be found on the
+            // 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));
-            (ordinary, Some(fallthrough))
+            (ordinary, Some(fallthrough), None)
         } else if let Style::Newtype = last.style {
             let ordinary = &variants[..variants.len() - 1];
-            let deserializer = quote!(_serde::__private::de::IdentifierDeserializer::from(__value));
-            let fallthrough = quote! {
-                _serde::__private::Result::map(
-                    _serde::Deserialize::deserialize(#deserializer),
-                    #this::#last_ident)
+            let fallthrough = |value| {
+                quote! {
+                    _serde::__private::Result::map(
+                        _serde::Deserialize::deserialize(
+                            _serde::__private::de::IdentifierDeserializer::from(#value)
+                        ),
+                        #this::#last_ident)
+                }
             };
-            (ordinary, Some(fallthrough))
+            (
+                ordinary,
+                Some(fallthrough(quote!(__value))),
+                Some(fallthrough(quote!(_serde::__private::de::Borrowed(
+                    __value
+                )))),
+            )
         } else {
-            (variants, None)
+            (variants, None, None)
         }
     } else {
-        (variants, None)
+        (variants, None, None)
     };
 
     let names_idents: Vec<_> = ordinary
@@ -2016,7 +2054,9 @@ fn deserialize_custom_identifier(
         &names_idents,
         is_variant,
         fallthrough,
+        fallthrough_borrowed,
         false,
+        cattrs.expecting(),
     ));
 
     quote_block! {
@@ -2046,21 +2086,20 @@ fn deserialize_identifier(
     fields: &[(String, Ident, Vec<String>)],
     is_variant: bool,
     fallthrough: Option<TokenStream>,
+    fallthrough_borrowed: Option<TokenStream>,
     collect_other_fields: bool,
+    expecting: Option<&str>,
 ) -> Fragment {
     let mut flat_fields = Vec::new();
     for (_, ident, aliases) in fields {
-        flat_fields.extend(aliases.iter().map(|alias| (alias, ident)))
+        flat_fields.extend(aliases.iter().map(|alias| (alias, ident)));
     }
 
-    let field_strs = flat_fields.iter().map(|(name, _)| name);
-    let field_borrowed_strs = flat_fields.iter().map(|(name, _)| name);
-    let field_bytes = flat_fields
+    let field_strs: &Vec<_> = &flat_fields.iter().map(|(name, _)| name).collect();
+    let field_bytes: &Vec<_> = &flat_fields
         .iter()
-        .map(|(name, _)| Literal::byte_string(name.as_bytes()));
-    let field_borrowed_bytes = flat_fields
-        .iter()
-        .map(|(name, _)| Literal::byte_string(name.as_bytes()));
+        .map(|(name, _)| Literal::byte_string(name.as_bytes()))
+        .collect();
 
     let constructors: &Vec<_> = &flat_fields
         .iter()
@@ -2071,11 +2110,11 @@ fn deserialize_identifier(
         .map(|(_, ident, _)| quote!(#this::#ident))
         .collect();
 
-    let expecting = if is_variant {
+    let expecting = expecting.unwrap_or(if is_variant {
         "variant identifier"
     } else {
         "field identifier"
-    };
+    });
 
     let index_expecting = if is_variant { "variant" } else { "field" };
 
@@ -2111,20 +2150,36 @@ fn deserialize_identifier(
         (None, None, None, None)
     };
 
-    let fallthrough_arm = if let Some(fallthrough) = fallthrough {
+    let fallthrough_arm_tokens;
+    let fallthrough_arm = if let Some(fallthrough) = &fallthrough {
         fallthrough
     } else if is_variant {
-        quote! {
+        fallthrough_arm_tokens = quote! {
             _serde::__private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
-        }
+        };
+        &fallthrough_arm_tokens
     } else {
-        quote! {
+        fallthrough_arm_tokens = quote! {
             _serde::__private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
-        }
+        };
+        &fallthrough_arm_tokens
+    };
+
+    let u64_fallthrough_arm_tokens;
+    let u64_fallthrough_arm = if let Some(fallthrough) = &fallthrough {
+        fallthrough
+    } else {
+        let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
+        u64_fallthrough_arm_tokens = quote! {
+            _serde::__private::Err(_serde::de::Error::invalid_value(
+                _serde::de::Unexpected::Unsigned(__value),
+                &#fallthrough_msg,
+            ))
+        };
+        &u64_fallthrough_arm_tokens
     };
 
     let variant_indices = 0_u64..;
-    let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
     let visit_other = if collect_other_fields {
         quote! {
             fn visit_bool<__E>(self, __value: bool) -> _serde::__private::Result<Self::Value, __E>
@@ -2217,37 +2272,6 @@ fn deserialize_identifier(
             {
                 _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Unit))
             }
-
-            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(
-                        #field_borrowed_strs => _serde::__private::Ok(#constructors),
-                    )*
-                    _ => {
-                        #value_as_borrowed_str_content
-                        #fallthrough_arm
-                    }
-                }
-            }
-
-            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(
-                        #field_borrowed_bytes => _serde::__private::Ok(#constructors),
-                    )*
-                    _ => {
-                        #bytes_to_str
-                        #value_as_borrowed_bytes_content
-                        #fallthrough_arm
-                    }
-                }
-            }
         }
     } else {
         quote! {
@@ -2259,15 +2283,50 @@ fn deserialize_identifier(
                     #(
                         #variant_indices => _serde::__private::Ok(#main_constructors),
                     )*
-                    _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                        _serde::de::Unexpected::Unsigned(__value),
-                        &#fallthrough_msg,
-                    ))
+                    _ => #u64_fallthrough_arm,
                 }
             }
         }
     };
 
+    let visit_borrowed = if fallthrough_borrowed.is_some() || collect_other_fields {
+        let fallthrough_borrowed_arm = fallthrough_borrowed.as_ref().unwrap_or(fallthrough_arm);
+        Some(quote! {
+            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E>
+            where
+                __E: _serde::de::Error,
+            {
+                match __value {
+                    #(
+                        #field_strs => _serde::__private::Ok(#constructors),
+                    )*
+                    _ => {
+                        #value_as_borrowed_str_content
+                        #fallthrough_borrowed_arm
+                    }
+                }
+            }
+
+            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::__private::Result<Self::Value, __E>
+            where
+                __E: _serde::de::Error,
+            {
+                match __value {
+                    #(
+                        #field_bytes => _serde::__private::Ok(#constructors),
+                    )*
+                    _ => {
+                        #bytes_to_str
+                        #value_as_borrowed_bytes_content
+                        #fallthrough_borrowed_arm
+                    }
+                }
+            }
+        })
+    } else {
+        None
+    };
+
     quote_block! {
         fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
             _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -2305,6 +2364,8 @@ fn deserialize_identifier(
                 }
             }
         }
+
+        #visit_borrowed
     }
 }
 
@@ -2827,44 +2888,61 @@ fn wrap_deserialize_variant_with(
     variant: &Variant,
     deserialize_with: &syn::ExprPath,
 ) -> (TokenStream, TokenStream, TokenStream) {
-    let this = &params.this;
-    let variant_ident = &variant.ident;
-
     let field_tys = variant.fields.iter().map(|field| field.ty);
     let (wrapper, wrapper_ty) =
         wrap_deserialize_with(params, &quote!((#(#field_tys),*)), deserialize_with);
 
+    let unwrap_fn = unwrap_to_variant_closure(params, variant, true);
+
+    (wrapper, wrapper_ty, unwrap_fn)
+}
+
+// Generates closure that converts single input parameter to the final value.
+fn unwrap_to_variant_closure(
+    params: &Parameters,
+    variant: &Variant,
+    with_wrapper: bool,
+) -> TokenStream {
+    let this = &params.this;
+    let variant_ident = &variant.ident;
+
+    let (arg, wrapper) = if with_wrapper {
+        (quote! { __wrap }, quote! { __wrap.value })
+    } else {
+        let field_tys = variant.fields.iter().map(|field| field.ty);
+        (quote! { __wrap: (#(#field_tys),*) }, quote! { __wrap })
+    };
+
     let field_access = (0..variant.fields.len()).map(|n| {
         Member::Unnamed(Index {
             index: n as u32,
             span: Span::call_site(),
         })
     });
-    let unwrap_fn = match variant.style {
+
+    match variant.style {
         Style::Struct if variant.fields.len() == 1 => {
             let member = &variant.fields[0].member;
             quote! {
-                |__wrap| #this::#variant_ident { #member: __wrap.value }
+                |#arg| #this::#variant_ident { #member: #wrapper }
             }
         }
         Style::Struct => {
             let members = variant.fields.iter().map(|field| &field.member);
             quote! {
-                |__wrap| #this::#variant_ident { #(#members: __wrap.value.#field_access),* }
+                |#arg| #this::#variant_ident { #(#members: #wrapper.#field_access),* }
             }
         }
         Style::Tuple => quote! {
-            |__wrap| #this::#variant_ident(#(__wrap.value.#field_access),*)
+            |#arg| #this::#variant_ident(#(#wrapper.#field_access),*)
         },
         Style::Newtype => quote! {
-            |__wrap| #this::#variant_ident(__wrap.value)
+            |#arg| #this::#variant_ident(#wrapper)
         },
         Style::Unit => quote! {
-            |__wrap| #this::#variant_ident
+            |#arg| #this::#variant_ident
         },
-    };
-
-    (wrapper, wrapper_ty, unwrap_fn)
+    }
 }
 
 fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {

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 {
@@ -23,7 +23,7 @@ pub fn wrap_in_const(
             use #path as _serde;
         },
         None => quote! {
-            #[allow(rust_2018_idioms, clippy::useless_attribute)]
+            #[allow(unused_extern_crates, clippy::useless_attribute)]
             extern crate serde as _serde;
         },
     };

serde_derive/src/internals/ast.rs

@@ -23,7 +23,7 @@ pub struct Container<'a> {
 
 /// The fields of a struct or enum.
 ///
-/// Analagous to `syn::Data`.
+/// Analogous to `syn::Data`.
 pub enum Data<'a> {
     Enum(Vec<Variant<'a>>),
     Struct(Style, Vec<Field<'a>>),

serde_derive/src/internals/attr.rs

@@ -1,10 +1,10 @@
+use internals::respan::respan;
 use internals::symbol::*;
 use internals::{ungroup, Ctxt};
-use proc_macro2::{Group, Span, TokenStream, TokenTree};
+use proc_macro2::{Spacing, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use std::borrow::Cow;
 use std::collections::BTreeSet;
-use std::str::FromStr;
 use syn;
 use syn::parse::{self, Parse, ParseStream};
 use syn::punctuated::Punctuated;
@@ -223,6 +223,8 @@ pub struct Container {
     has_flatten: bool,
     serde_path: Option<syn::Path>,
     is_packed: bool,
+    /// Error message generated when type can't be deserialized
+    expecting: Option<String>,
 }
 
 /// Styles of representing an enum.
@@ -305,6 +307,7 @@ impl Container {
         let mut field_identifier = BoolAttr::none(cx, FIELD_IDENTIFIER);
         let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
         let mut serde_path = Attr::none(cx, CRATE);
+        let mut expecting = Attr::none(cx, EXPECTING);
 
         for meta_item in item
             .attrs
@@ -337,13 +340,7 @@ impl Container {
                                 rename_all_ser_rule.set(&m.path, rename_rule);
                                 rename_all_de_rule.set(&m.path, rename_rule);
                             }
-                            Err(()) => cx.error_spanned_by(
-                                s,
-                                format!(
-                                    "unknown rename rule for #[serde(rename_all = {:?})]",
-                                    s.value(),
-                                ),
-                            ),
+                            Err(err) => cx.error_spanned_by(s, err),
                         }
                     }
                 }
@@ -354,25 +351,13 @@ impl Container {
                         if let Some(ser) = ser {
                             match RenameRule::from_str(&ser.value()) {
                                 Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    ser,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        ser.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(ser, err),
                             }
                         }
                         if let Some(de) = de {
                             match RenameRule::from_str(&de.value()) {
                                 Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    de,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        de.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(de, err),
                             }
                         }
                     }
@@ -571,7 +556,14 @@ impl Container {
                 // Parse `#[serde(crate = "foo")]`
                 Meta(NameValue(m)) if m.path == CRATE => {
                     if let Ok(path) = parse_lit_into_path(cx, CRATE, &m.lit) {
-                        serde_path.set(&m.path, path)
+                        serde_path.set(&m.path, path);
+                    }
+                }
+
+                // Parse `#[serde(expecting = "a message")]`
+                Meta(NameValue(m)) if m.path == EXPECTING => {
+                    if let Ok(s) = get_lit_str(cx, EXPECTING, &m.lit) {
+                        expecting.set(&m.path, s.value());
                     }
                 }
 
@@ -627,6 +619,7 @@ impl Container {
             has_flatten: false,
             serde_path: serde_path.get(),
             is_packed,
+            expecting: expecting.get(),
         }
     }
 
@@ -702,6 +695,12 @@ impl Container {
         self.custom_serde_path()
             .map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
     }
+
+    /// Error message generated when type can't be deserialized.
+    /// If `None`, default message will be used
+    pub fn expecting(&self) -> Option<&str> {
+        self.expecting.as_ref().map(String::as_ref)
+    }
 }
 
 fn decide_tag(
@@ -914,13 +913,7 @@ impl Variant {
                                 rename_all_ser_rule.set(&m.path, rename_rule);
                                 rename_all_de_rule.set(&m.path, rename_rule);
                             }
-                            Err(()) => cx.error_spanned_by(
-                                s,
-                                format!(
-                                    "unknown rename rule for #[serde(rename_all = {:?})]",
-                                    s.value()
-                                ),
-                            ),
+                            Err(err) => cx.error_spanned_by(s, err),
                         }
                     }
                 }
@@ -931,25 +924,13 @@ impl Variant {
                         if let Some(ser) = ser {
                             match RenameRule::from_str(&ser.value()) {
                                 Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    ser,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        ser.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(ser, err),
                             }
                         }
                         if let Some(de) = de {
                             match RenameRule::from_str(&de.value()) {
                                 Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    de,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        de.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(de, err),
                             }
                         }
                     }
@@ -1628,7 +1609,7 @@ fn get_lit_str2<'a>(
 fn parse_lit_into_path(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Path, ()> {
     let string = get_lit_str(cx, attr_name, lit)?;
     parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
+        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()));
     })
 }
 
@@ -1639,7 +1620,7 @@ fn parse_lit_into_expr_path(
 ) -> Result<syn::ExprPath, ()> {
     let string = get_lit_str(cx, attr_name, lit)?;
     parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
+        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()));
     })
 }
 
@@ -1668,7 +1649,7 @@ fn parse_lit_into_ty(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn
         cx.error_spanned_by(
             lit,
             format!("failed to parse type: {} = {:?}", attr_name, string.value()),
-        )
+        );
     })
 }
 
@@ -1921,14 +1902,39 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
         syn::Type::Group(ty) => {
             collect_lifetimes(&ty.elem, out);
         }
+        syn::Type::Macro(ty) => {
+            collect_lifetimes_from_tokens(ty.mac.tokens.clone(), out);
+        }
         syn::Type::BareFn(_)
         | syn::Type::Never(_)
         | syn::Type::TraitObject(_)
         | syn::Type::ImplTrait(_)
         | syn::Type::Infer(_)
-        | syn::Type::Macro(_)
-        | syn::Type::Verbatim(_)
-        | _ => {}
+        | syn::Type::Verbatim(_) => {}
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => {}
+    }
+}
+
+fn collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet<syn::Lifetime>) {
+    let mut iter = tokens.into_iter();
+    while let Some(tt) = iter.next() {
+        match &tt {
+            TokenTree::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
+                if let Some(TokenTree::Ident(ident)) = iter.next() {
+                    out.insert(syn::Lifetime {
+                        apostrophe: op.span(),
+                        ident,
+                    });
+                }
+            }
+            TokenTree::Group(group) => {
+                let tokens = group.stream();
+                collect_lifetimes_from_tokens(tokens, out);
+            }
+            _ => {}
+        }
     }
 }
 
@@ -1942,20 +1948,5 @@ where
 
 fn spanned_tokens(s: &syn::LitStr) -> parse::Result<TokenStream> {
     let stream = syn::parse_str(&s.value())?;
-    Ok(respan_token_stream(stream, s.span()))
-}
-
-fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
-    stream
-        .into_iter()
-        .map(|token| respan_token_tree(token, span))
-        .collect()
-}
-
-fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
-    if let TokenTree::Group(g) = &mut token {
-        *g = Group::new(g.delimiter(), respan_token_stream(g.stream(), span));
-    }
-    token.set_span(span);
-    token
+    Ok(respan(stream, s.span()))
 }

serde_derive/src/internals/case.rs

@@ -5,7 +5,7 @@
 #[allow(deprecated, unused_imports)]
 use std::ascii::AsciiExt;
 
-use std::str::FromStr;
+use std::fmt::{self, Debug, Display};
 
 use self::RenameRule::*;
 
@@ -17,7 +17,7 @@ pub enum RenameRule {
     /// Rename direct children to "lowercase" style.
     LowerCase,
     /// Rename direct children to "UPPERCASE" style.
-    UPPERCASE,
+    UpperCase,
     /// Rename direct children to "PascalCase" style, as typically used for
     /// enum variants.
     PascalCase,
@@ -35,13 +35,35 @@ pub enum RenameRule {
     ScreamingKebabCase,
 }
 
+static RENAME_RULES: &[(&str, RenameRule)] = &[
+    ("lowercase", LowerCase),
+    ("UPPERCASE", UpperCase),
+    ("PascalCase", PascalCase),
+    ("camelCase", CamelCase),
+    ("snake_case", SnakeCase),
+    ("SCREAMING_SNAKE_CASE", ScreamingSnakeCase),
+    ("kebab-case", KebabCase),
+    ("SCREAMING-KEBAB-CASE", ScreamingKebabCase),
+];
+
 impl RenameRule {
+    pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError> {
+        for (name, rule) in RENAME_RULES {
+            if rename_all_str == *name {
+                return Ok(*rule);
+            }
+        }
+        Err(ParseError {
+            unknown: rename_all_str,
+        })
+    }
+
     /// Apply a renaming rule to an enum variant, returning the version expected in the source.
     pub fn apply_to_variant(&self, variant: &str) -> String {
         match *self {
             None | PascalCase => variant.to_owned(),
             LowerCase => variant.to_ascii_lowercase(),
-            UPPERCASE => variant.to_ascii_uppercase(),
+            UpperCase => variant.to_ascii_uppercase(),
             CamelCase => variant[..1].to_ascii_lowercase() + &variant[1..],
             SnakeCase => {
                 let mut snake = String::new();
@@ -65,7 +87,7 @@ impl RenameRule {
     pub fn apply_to_field(&self, field: &str) -> String {
         match *self {
             None | LowerCase | SnakeCase => field.to_owned(),
-            UPPERCASE => field.to_ascii_uppercase(),
+            UpperCase => field.to_ascii_uppercase(),
             PascalCase => {
                 let mut pascal = String::new();
                 let mut capitalize = true;
@@ -92,21 +114,22 @@ impl RenameRule {
     }
 }
 
-impl FromStr for RenameRule {
-    type Err = ();
+pub struct ParseError<'a> {
+    unknown: &'a str,
+}
 
-    fn from_str(rename_all_str: &str) -> Result<Self, Self::Err> {
-        match rename_all_str {
-            "lowercase" => Ok(LowerCase),
-            "UPPERCASE" => Ok(UPPERCASE),
-            "PascalCase" => Ok(PascalCase),
-            "camelCase" => Ok(CamelCase),
-            "snake_case" => Ok(SnakeCase),
-            "SCREAMING_SNAKE_CASE" => Ok(ScreamingSnakeCase),
-            "kebab-case" => Ok(KebabCase),
-            "SCREAMING-KEBAB-CASE" => Ok(ScreamingKebabCase),
-            _ => Err(()),
+impl<'a> Display for ParseError<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("unknown rename rule `rename_all = ")?;
+        Debug::fmt(self.unknown, f)?;
+        f.write_str("`, expected one of ")?;
+        for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() {
+            if i > 0 {
+                f.write_str(", ")?;
+            }
+            Debug::fmt(name, f)?;
         }
+        Ok(())
     }
 }
 
@@ -131,7 +154,7 @@ fn rename_variants() {
     ] {
         assert_eq!(None.apply_to_variant(original), original);
         assert_eq!(LowerCase.apply_to_variant(original), lower);
-        assert_eq!(UPPERCASE.apply_to_variant(original), upper);
+        assert_eq!(UpperCase.apply_to_variant(original), upper);
         assert_eq!(PascalCase.apply_to_variant(original), original);
         assert_eq!(CamelCase.apply_to_variant(original), camel);
         assert_eq!(SnakeCase.apply_to_variant(original), snake);
@@ -163,7 +186,7 @@ fn rename_fields() {
         ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"),
     ] {
         assert_eq!(None.apply_to_field(original), original);
-        assert_eq!(UPPERCASE.apply_to_field(original), upper);
+        assert_eq!(UpperCase.apply_to_field(original), upper);
         assert_eq!(PascalCase.apply_to_field(original), pascal);
         assert_eq!(CamelCase.apply_to_field(original), camel);
         assert_eq!(SnakeCase.apply_to_field(original), original);

serde_derive/src/internals/check.rs

@@ -260,7 +260,7 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
         cx.error_spanned_by(
             cont.original,
             format!("variant field name `{}` conflicts with internal tag", tag),
-        )
+        );
     };
 
     for variant in variants {
@@ -396,7 +396,7 @@ fn member_message(member: &Member) -> String {
 }
 
 fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ty) = ungroup(&field.ty) {
+    if let Type::Path(ty) = ungroup(field.ty) {
         if let Some(seg) = ty.path.segments.last() {
             if seg.ident == "PhantomData" {
                 return false;

serde_derive/src/internals/mod.rs

@@ -4,8 +4,12 @@ pub mod attr;
 mod ctxt;
 pub use self::ctxt::Ctxt;
 
+mod receiver;
+pub use self::receiver::replace_receiver;
+
 mod case;
 mod check;
+mod respan;
 mod symbol;
 
 use syn::Type;

serde_derive/src/internals/receiver.rs

@@ -0,0 +1,285 @@
+use internals::respan::respan;
+use proc_macro2::Span;
+use quote::ToTokens;
+use std::mem;
+use syn::punctuated::Punctuated;
+use syn::{
+    parse_quote, Data, DeriveInput, Expr, ExprPath, GenericArgument, GenericParam, Generics, Macro,
+    Path, PathArguments, QSelf, ReturnType, Type, TypeParamBound, TypePath, WherePredicate,
+};
+
+pub fn replace_receiver(input: &mut DeriveInput) {
+    let self_ty = {
+        let ident = &input.ident;
+        let ty_generics = input.generics.split_for_impl().1;
+        parse_quote!(#ident #ty_generics)
+    };
+    let mut visitor = ReplaceReceiver(&self_ty);
+    visitor.visit_generics_mut(&mut input.generics);
+    visitor.visit_data_mut(&mut input.data);
+}
+
+struct ReplaceReceiver<'a>(&'a TypePath);
+
+impl ReplaceReceiver<'_> {
+    fn self_ty(&self, span: Span) -> TypePath {
+        let tokens = self.0.to_token_stream();
+        let respanned = respan(tokens, span);
+        syn::parse2(respanned).unwrap()
+    }
+
+    fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) {
+        if path.leading_colon.is_some() || path.segments[0].ident != "Self" {
+            return;
+        }
+
+        if path.segments.len() == 1 {
+            self.self_to_expr_path(path);
+            return;
+        }
+
+        let span = path.segments[0].ident.span();
+        *qself = Some(QSelf {
+            lt_token: Token![<](span),
+            ty: Box::new(Type::Path(self.self_ty(span))),
+            position: 0,
+            as_token: None,
+            gt_token: Token![>](span),
+        });
+
+        path.leading_colon = Some(**path.segments.pairs().next().unwrap().punct().unwrap());
+
+        let segments = mem::replace(&mut path.segments, Punctuated::new());
+        path.segments = segments.into_pairs().skip(1).collect();
+    }
+
+    fn self_to_expr_path(&self, path: &mut Path) {
+        let self_ty = self.self_ty(path.segments[0].ident.span());
+        let variant = mem::replace(path, self_ty.path);
+        for segment in &mut path.segments {
+            if let PathArguments::AngleBracketed(bracketed) = &mut segment.arguments {
+                if bracketed.colon2_token.is_none() && !bracketed.args.is_empty() {
+                    bracketed.colon2_token = Some(<Token![::]>::default());
+                }
+            }
+        }
+        if variant.segments.len() > 1 {
+            path.segments.push_punct(<Token![::]>::default());
+            path.segments.extend(variant.segments.into_pairs().skip(1));
+        }
+    }
+}
+
+impl ReplaceReceiver<'_> {
+    // `Self` -> `Receiver`
+    fn visit_type_mut(&mut self, ty: &mut Type) {
+        let span = if let Type::Path(node) = ty {
+            if node.qself.is_none() && node.path.is_ident("Self") {
+                node.path.segments[0].ident.span()
+            } else {
+                self.visit_type_path_mut(node);
+                return;
+            }
+        } else {
+            self.visit_type_mut_impl(ty);
+            return;
+        };
+        *ty = self.self_ty(span).into();
+    }
+
+    // `Self::Assoc` -> `<Receiver>::Assoc`
+    fn visit_type_path_mut(&mut self, ty: &mut TypePath) {
+        if ty.qself.is_none() {
+            self.self_to_qself(&mut ty.qself, &mut ty.path);
+        }
+        self.visit_type_path_mut_impl(ty);
+    }
+
+    // `Self::method` -> `<Receiver>::method`
+    fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
+        if expr.qself.is_none() {
+            self.self_to_qself(&mut expr.qself, &mut expr.path);
+        }
+        self.visit_expr_path_mut_impl(expr);
+    }
+
+    // Everything below is simply traversing the syntax tree.
+
+    fn visit_type_mut_impl(&mut self, ty: &mut Type) {
+        match ty {
+            Type::Array(ty) => {
+                self.visit_type_mut(&mut ty.elem);
+                self.visit_expr_mut(&mut ty.len);
+            }
+            Type::BareFn(ty) => {
+                for arg in &mut ty.inputs {
+                    self.visit_type_mut(&mut arg.ty);
+                }
+                self.visit_return_type_mut(&mut ty.output);
+            }
+            Type::Group(ty) => self.visit_type_mut(&mut ty.elem),
+            Type::ImplTrait(ty) => {
+                for bound in &mut ty.bounds {
+                    self.visit_type_param_bound_mut(bound);
+                }
+            }
+            Type::Macro(ty) => self.visit_macro_mut(&mut ty.mac),
+            Type::Paren(ty) => self.visit_type_mut(&mut ty.elem),
+            Type::Path(ty) => {
+                if let Some(qself) = &mut ty.qself {
+                    self.visit_type_mut(&mut qself.ty);
+                }
+                self.visit_path_mut(&mut ty.path);
+            }
+            Type::Ptr(ty) => self.visit_type_mut(&mut ty.elem),
+            Type::Reference(ty) => self.visit_type_mut(&mut ty.elem),
+            Type::Slice(ty) => self.visit_type_mut(&mut ty.elem),
+            Type::TraitObject(ty) => {
+                for bound in &mut ty.bounds {
+                    self.visit_type_param_bound_mut(bound);
+                }
+            }
+            Type::Tuple(ty) => {
+                for elem in &mut ty.elems {
+                    self.visit_type_mut(elem);
+                }
+            }
+
+            Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
+
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => {}
+        }
+    }
+
+    fn visit_type_path_mut_impl(&mut self, ty: &mut TypePath) {
+        if let Some(qself) = &mut ty.qself {
+            self.visit_type_mut(&mut qself.ty);
+        }
+        self.visit_path_mut(&mut ty.path);
+    }
+
+    fn visit_expr_path_mut_impl(&mut self, expr: &mut ExprPath) {
+        if let Some(qself) = &mut expr.qself {
+            self.visit_type_mut(&mut qself.ty);
+        }
+        self.visit_path_mut(&mut expr.path);
+    }
+
+    fn visit_path_mut(&mut self, path: &mut Path) {
+        for segment in &mut path.segments {
+            self.visit_path_arguments_mut(&mut segment.arguments);
+        }
+    }
+
+    fn visit_path_arguments_mut(&mut self, arguments: &mut PathArguments) {
+        match arguments {
+            PathArguments::None => {}
+            PathArguments::AngleBracketed(arguments) => {
+                for arg in &mut arguments.args {
+                    match arg {
+                        GenericArgument::Type(arg) => self.visit_type_mut(arg),
+                        GenericArgument::Binding(arg) => self.visit_type_mut(&mut arg.ty),
+                        GenericArgument::Lifetime(_)
+                        | GenericArgument::Constraint(_)
+                        | GenericArgument::Const(_) => {}
+                    }
+                }
+            }
+            PathArguments::Parenthesized(arguments) => {
+                for argument in &mut arguments.inputs {
+                    self.visit_type_mut(argument);
+                }
+                self.visit_return_type_mut(&mut arguments.output);
+            }
+        }
+    }
+
+    fn visit_return_type_mut(&mut self, return_type: &mut ReturnType) {
+        match return_type {
+            ReturnType::Default => {}
+            ReturnType::Type(_, output) => self.visit_type_mut(output),
+        }
+    }
+
+    fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
+        match bound {
+            TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path),
+            TypeParamBound::Lifetime(_) => {}
+        }
+    }
+
+    fn visit_generics_mut(&mut self, generics: &mut Generics) {
+        for param in &mut generics.params {
+            match param {
+                GenericParam::Type(param) => {
+                    for bound in &mut param.bounds {
+                        self.visit_type_param_bound_mut(bound);
+                    }
+                }
+                GenericParam::Lifetime(_) | GenericParam::Const(_) => {}
+            }
+        }
+        if let Some(where_clause) = &mut generics.where_clause {
+            for predicate in &mut where_clause.predicates {
+                match predicate {
+                    WherePredicate::Type(predicate) => {
+                        self.visit_type_mut(&mut predicate.bounded_ty);
+                        for bound in &mut predicate.bounds {
+                            self.visit_type_param_bound_mut(bound);
+                        }
+                    }
+                    WherePredicate::Lifetime(_) | WherePredicate::Eq(_) => {}
+                }
+            }
+        }
+    }
+
+    fn visit_data_mut(&mut self, data: &mut Data) {
+        match data {
+            Data::Struct(data) => {
+                for field in &mut data.fields {
+                    self.visit_type_mut(&mut field.ty);
+                }
+            }
+            Data::Enum(data) => {
+                for variant in &mut data.variants {
+                    for field in &mut variant.fields {
+                        self.visit_type_mut(&mut field.ty);
+                    }
+                }
+            }
+            Data::Union(_) => {}
+        }
+    }
+
+    fn visit_expr_mut(&mut self, expr: &mut Expr) {
+        match expr {
+            Expr::Binary(expr) => {
+                self.visit_expr_mut(&mut expr.left);
+                self.visit_expr_mut(&mut expr.right);
+            }
+            Expr::Call(expr) => {
+                self.visit_expr_mut(&mut expr.func);
+                for arg in &mut expr.args {
+                    self.visit_expr_mut(arg);
+                }
+            }
+            Expr::Cast(expr) => {
+                self.visit_expr_mut(&mut expr.expr);
+                self.visit_type_mut(&mut expr.ty);
+            }
+            Expr::Field(expr) => self.visit_expr_mut(&mut expr.base),
+            Expr::Index(expr) => {
+                self.visit_expr_mut(&mut expr.expr);
+                self.visit_expr_mut(&mut expr.index);
+            }
+            Expr::Paren(expr) => self.visit_expr_mut(&mut expr.expr),
+            Expr::Path(expr) => self.visit_expr_path_mut(expr),
+            Expr::Unary(expr) => self.visit_expr_mut(&mut expr.expr),
+            _ => {}
+        }
+    }
+
+    fn visit_macro_mut(&mut self, _mac: &mut Macro) {}
+}

serde_derive/src/internals/respan.rs

@@ -0,0 +1,16 @@
+use proc_macro2::{Group, Span, TokenStream, TokenTree};
+
+pub(crate) fn respan(stream: TokenStream, span: Span) -> TokenStream {
+    stream
+        .into_iter()
+        .map(|token| respan_token(token, span))
+        .collect()
+}
+
+fn respan_token(mut token: TokenTree, span: Span) -> TokenTree {
+    if let TokenTree::Group(g) = &mut token {
+        *g = Group::new(g.delimiter(), respan(g.stream(), span));
+    }
+    token.set_span(span);
+    token
+}

serde_derive/src/internals/symbol.rs

@@ -35,6 +35,7 @@ pub const TRY_FROM: Symbol = Symbol("try_from");
 pub const UNTAGGED: Symbol = Symbol("untagged");
 pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
 pub const WITH: Symbol = Symbol("with");
+pub const EXPECTING: Symbol = Symbol("expecting");
 
 impl PartialEq<Symbol> for Ident {
     fn eq(&self, word: &Symbol) -> bool {

serde_derive/src/lib.rs

@@ -13,13 +13,19 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.120")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.145")]
 #![allow(unknown_lints, bare_trait_objects)]
-#![deny(clippy::all, clippy::pedantic)]
 // Ignored clippy lints
 #![allow(
+    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
+    clippy::branches_sharing_code,
     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,
     clippy::match_like_matches_macro,
     clippy::needless_pass_by_value,
     clippy::too_many_arguments,
@@ -35,11 +41,14 @@
     clippy::checked_conversions,
     clippy::doc_markdown,
     clippy::enum_glob_use,
-    clippy::filter_map,
     clippy::indexing_slicing,
     clippy::items_after_statements,
+    clippy::let_underscore_drop,
+    clippy::manual_assert,
     clippy::map_err_ignore,
     clippy::match_same_arms,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
+    clippy::match_wildcard_for_single_variants,
     clippy::module_name_repetitions,
     clippy::must_use_candidate,
     clippy::option_if_let_else,
@@ -48,9 +57,11 @@
     clippy::struct_excessive_bools,
     clippy::too_many_lines,
     clippy::unseparated_literal_suffix,
+    clippy::unused_self,
     clippy::use_self,
     clippy::wildcard_imports
 )]
+#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]
 
 #[macro_use]
 extern crate quote;
@@ -78,16 +89,16 @@ mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&input)
+    let mut input = parse_macro_input!(input as DeriveInput);
+    ser::expand_derive_serialize(&mut input)
         .unwrap_or_else(to_compile_errors)
         .into()
 }
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&input)
+    let mut input = parse_macro_input!(input as DeriveInput);
+    de::expand_derive_deserialize(&mut input)
         .unwrap_or_else(to_compile_errors)
         .into()
 }

serde_derive/src/pretend.rs

@@ -1,7 +1,7 @@
-use proc_macro2::{Span, TokenStream};
-use syn::Ident;
+use proc_macro2::TokenStream;
+use quote::format_ident;
 
-use internals::ast::{Container, Data, Field, Style};
+use internals::ast::{Container, Data, Field, Style, Variant};
 
 // Suppress dead_code warnings that would otherwise appear when using a remote
 // derive. Other than this pretend code, a struct annotated with remote derive
@@ -20,8 +20,8 @@ use internals::ast::{Container, Data, Field, Style};
 //     8 | enum EnumDef { V }
 //       |                ^
 //
-pub fn pretend_used(cont: &Container) -> TokenStream {
-    let pretend_fields = pretend_fields_used(cont);
+pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
+    let pretend_fields = pretend_fields_used(cont, is_packed);
     let pretend_variants = pretend_variants_used(cont);
 
     quote! {
@@ -32,49 +32,117 @@ pub fn pretend_used(cont: &Container) -> TokenStream {
 
 // For structs with named fields, expands to:
 //
+//     match None::<&T> {
+//         Some(T { a: __v0, b: __v1 }) => {}
+//         _ => {}
+//     }
+//
+// For packed structs on sufficiently new rustc, expands to:
+//
+//     match None::<&T> {
+//         Some(__v @ T { a: _, b: _ }) => {
+//             let _ = addr_of!(__v.a);
+//             let _ = addr_of!(__v.b);
+//         }
+//         _ => {}
+//     }
+//
+// For packed structs on older rustc, we assume Sized and !Drop, and expand to:
+//
 //     match None::<T> {
-//         Some(T { a: ref __v0, b: ref __v1 }) => {}
+//         Some(T { a: __v0, b: __v1 }) => {}
 //         _ => {}
 //     }
 //
 // For enums, expands to the following but only including struct variants:
 //
-//     match None::<T> {
-//         Some(T::A { a: ref __v0 }) => {}
-//         Some(T::B { b: ref __v0 }) => {}
+//     match None::<&T> {
+//         Some(T::A { a: __v0 }) => {}
+//         Some(T::B { b: __v0 }) => {}
 //         _ => {}
 //     }
 //
-// The `ref` is important in case the user has written a Drop impl on their
-// type. Rust does not allow destructuring a struct or enum that has a Drop
-// impl.
-fn pretend_fields_used(cont: &Container) -> TokenStream {
+fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
+    match &cont.data {
+        Data::Enum(variants) => pretend_fields_used_enum(cont, variants),
+        Data::Struct(Style::Struct, fields) => {
+            if is_packed {
+                pretend_fields_used_struct_packed(cont, fields)
+            } else {
+                pretend_fields_used_struct(cont, fields)
+            }
+        }
+        Data::Struct(_, _) => quote!(),
+    }
+}
+
+fn pretend_fields_used_struct(cont: &Container, fields: &[Field]) -> TokenStream {
     let type_ident = &cont.ident;
     let (_, ty_generics, _) = cont.generics.split_for_impl();
 
-    let patterns = match &cont.data {
-        Data::Enum(variants) => variants
-            .iter()
-            .filter_map(|variant| match variant.style {
-                Style::Struct => {
-                    let variant_ident = &variant.ident;
-                    let pat = struct_pattern(&variant.fields);
-                    Some(quote!(#type_ident::#variant_ident #pat))
-                }
-                _ => None,
-            })
-            .collect::<Vec<_>>(),
-        Data::Struct(Style::Struct, fields) => {
-            let pat = struct_pattern(fields);
-            vec![quote!(#type_ident #pat)]
-        }
-        Data::Struct(_, _) => {
-            return quote!();
-        }
-    };
+    let members = fields.iter().map(|field| &field.member);
+    let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
 
     quote! {
-        match _serde::__private::None::<#type_ident #ty_generics> {
+        match _serde::__private::None::<&#type_ident #ty_generics> {
+            _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
+            _ => {}
+        }
+    }
+}
+
+fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> TokenStream {
+    let type_ident = &cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+
+    let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();
+
+    #[cfg(not(no_ptr_addr_of))]
+    {
+        quote! {
+            match _serde::__private::None::<&#type_ident #ty_generics> {
+                _serde::__private::Some(__v @ #type_ident { #(#members: _),* }) => {
+                    #(
+                        let _ = _serde::__private::ptr::addr_of!(__v.#members);
+                    )*
+                }
+                _ => {}
+            }
+        }
+    }
+
+    #[cfg(no_ptr_addr_of)]
+    {
+        let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
+
+        quote! {
+            match _serde::__private::None::<#type_ident #ty_generics> {
+                _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
+                _ => {}
+            }
+        }
+    }
+}
+
+fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStream {
+    let type_ident = &cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+
+    let patterns = variants
+        .iter()
+        .filter_map(|variant| match variant.style {
+            Style::Struct => {
+                let variant_ident = &variant.ident;
+                let members = variant.fields.iter().map(|field| &field.member);
+                let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
+                Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
+            }
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+
+    quote! {
+        match _serde::__private::None::<&#type_ident #ty_generics> {
             #(
                 _serde::__private::Some(#patterns) => {}
             )*
@@ -107,7 +175,7 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
     let cases = variants.iter().map(|variant| {
         let variant_ident = &variant.ident;
         let placeholders = &(0..variant.fields.len())
-            .map(|i| Ident::new(&format!("__v{}", i), Span::call_site()))
+            .map(|i| format_ident!("__v{}", i))
             .collect::<Vec<_>>();
 
         let pat = match variant.style {
@@ -131,10 +199,3 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
 
     quote!(#(#cases)*)
 }
-
-fn struct_pattern(fields: &[Field]) -> TokenStream {
-    let members = fields.iter().map(|field| &field.member);
-    let placeholders =
-        (0..fields.len()).map(|i| Ident::new(&format!("__v{}", i), Span::call_site()));
-    quote!({ #(#members: ref #placeholders),* })
-}

serde_derive/src/ser.rs

@@ -6,10 +6,14 @@ use bound;
 use dummy;
 use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt, Derive};
+use internals::{attr, replace_receiver, Ctxt, Derive};
 use pretend;
 
-pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_serialize(
+    input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+    replace_receiver(input);
+
     let ctxt = Ctxt::new();
     let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
         Some(cont) => cont,
@@ -26,7 +30,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;
-        let used = pretend::pretend_used(&cont);
+        let used = pretend::pretend_used(&cont, params.is_packed);
         quote! {
             impl #impl_generics #ident #ty_generics #where_clause {
                 #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
@@ -1095,7 +1099,7 @@ fn serialize_struct_visitor(
             let mut field_expr = if is_enum {
                 quote!(#member)
             } else {
-                get_member(params, field, &member)
+                get_member(params, field, member)
             };
 
             let key_expr = field.attrs.name().serialize_name();

serde_derive_internals/.clippy.toml

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

serde_derive_internals/Cargo.toml

@@ -1,14 +1,15 @@
 [package]
 name = "serde_derive_internals"
-version = "0.25.0" # remember to update html_root_url
+version = "0.26.0" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-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"
@@ -16,7 +17,7 @@ path = "lib.rs"
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.33", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+syn = { version = "1.0.90", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/build.rs

@@ -0,0 +1,12 @@
+use std::path::Path;
+
+fn main() {
+    // Sometimes on Windows the git checkout does not correctly wire up the
+    // symlink from serde_derive_internals/src to serde_derive/src/internals.
+    // When this happens we'll just build based on relative paths within the git
+    // repo.
+    let mod_behind_symlink = Path::new("src/mod.rs");
+    if !mod_behind_symlink.exists() {
+        println!("cargo:rustc-cfg=serde_build_from_git");
+    }
+}

serde_derive_internals/lib.rs

@@ -1,17 +1,40 @@
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.25.0")]
+#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.26.0")]
 #![allow(unknown_lints, bare_trait_objects)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        cognitive_complexity,
-        redundant_field_names,
-        result_unit_err,
-        trivially_copy_pass_by_ref,
-        wildcard_in_or_patterns,
-        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-        unnested_or_patterns,
-    )
+// Ignored clippy lints
+#![allow(
+    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,
+    clippy::redundant_field_names,
+    clippy::result_unit_err,
+    clippy::should_implement_trait,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::wildcard_in_or_patterns,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+    clippy::unnested_or_patterns,
+)]
+// Ignored clippy_pedantic lints
+#![allow(
+    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
+    clippy::match_wildcard_for_single_variants,
+    clippy::missing_errors_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::struct_excessive_bools,
+    clippy::too_many_lines,
+    clippy::unused_self,
+    clippy::wildcard_imports
 )]
 
 #[macro_use]
@@ -20,7 +43,8 @@ extern crate syn;
 extern crate proc_macro2;
 extern crate quote;
 
-#[path = "src/mod.rs"]
+#[cfg_attr(serde_build_from_git, path = "../serde_derive/src/internals/mod.rs")]
+#[cfg_attr(not(serde_build_from_git), path = "src/mod.rs")]
 mod internals;
 
 pub use internals::*;

serde_test/.clippy.toml

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

serde_test/Cargo.toml

@@ -1,15 +1,18 @@
 [package]
 name = "serde_test"
-version = "1.0.120" # remember to update html_root_url
+version = "1.0.145" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-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

@@ -0,0 +1,48 @@
+use std::env;
+use std::process::Command;
+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
+// these cfgs other than by executing our build script.
+fn main() {
+    let minor = match rustc_minor_version() {
+        Some(minor) => minor,
+        None => return,
+    };
+
+    // #[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=no_track_caller");
+    }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+    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;
+    }
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    u32::from_str(next).ok()
+}

serde_test/src/assert.rs

@@ -28,6 +28,7 @@ use std::fmt::Debug;
 ///     Token::StructEnd,
 /// ]);
 /// ```
+#[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,
@@ -58,7 +59,8 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
-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,
 {
@@ -110,7 +112,8 @@ where
 ///     assert_ser_tokens_error(&example, expected, error);
 /// }
 /// ```
-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,
 {
@@ -147,6 +150,7 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
+#[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,
@@ -199,6 +203,7 @@ where
 ///     "unknown field `x`, expected `a` or `b`",
 /// );
 /// ```
+#[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/configure.rs

@@ -777,6 +777,17 @@ macro_rules! impl_deserializer {
             {
                 self.0.next_value_seed($wrapper(seed))
             }
+            fn next_entry_seed<K, V>(
+                &mut self,
+                kseed: K,
+                vseed: V,
+            ) -> Result<Option<(K::Value, V::Value)>, D::Error>
+            where
+                K: DeserializeSeed<'de>,
+                V: DeserializeSeed<'de>,
+            {
+                self.0.next_entry_seed($wrapper(kseed), $wrapper(vseed))
+            }
             fn size_hint(&self) -> Option<usize> {
                 self.0.size_hint()
             }

serde_test/src/de.rs

@@ -168,14 +168,42 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                         self.next_token();
                         visitor.visit_str(variant)
                     }
+                    (Token::BorrowedStr(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_borrowed_str(variant)
+                    }
+                    (Token::String(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_string(variant.to_string())
+                    }
                     (Token::Bytes(variant), Token::Unit) => {
                         self.next_token();
                         visitor.visit_bytes(variant)
                     }
+                    (Token::BorrowedBytes(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_borrowed_bytes(variant)
+                    }
+                    (Token::ByteBuf(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_byte_buf(variant.to_vec())
+                    }
+                    (Token::U8(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_u8(variant)
+                    }
+                    (Token::U16(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_u16(variant)
+                    }
                     (Token::U32(variant), Token::Unit) => {
                         self.next_token();
                         visitor.visit_u32(variant)
                     }
+                    (Token::U64(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_u64(variant)
+                    }
                     (variant, Token::Unit) => unexpected!(variant),
                     (variant, _) => {
                         visitor.visit_map(EnumMapVisitor::new(self, variant, EnumFormat::Any))
@@ -250,9 +278,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             {
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
-            _ => {
-                unexpected!(self.next_token());
-            }
+            _ => self.deserialize_any(visitor),
         }
     }
 

serde_test/src/lib.rs

@@ -144,20 +144,25 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.120")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.145")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
 // Ignored clippy_pedantic lints
 #![cfg_attr(
     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,
+        missing_panics_doc,
         module_name_repetitions,
         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
     )

serde_test/src/ser.rs

@@ -32,18 +32,18 @@ impl<'a> Serializer<'a> {
 }
 
 macro_rules! assert_next_token {
-    ($ser:expr, $expected:ident) => {
-        assert_next_token!($ser, stringify!($expected), Token::$expected, true);
-    };
-    ($ser:expr, $expected:ident($v:expr)) => {
+    ($ser:expr, $actual:ident) => {{
+        assert_next_token!($ser, stringify!($actual), Token::$actual, true);
+    }};
+    ($ser:expr, $actual:ident($v:expr)) => {{
         assert_next_token!(
             $ser,
-            format_args!(concat!(stringify!($expected), "({:?})"), $v),
-            Token::$expected(v),
+            format_args!(concat!(stringify!($actual), "({:?})"), $v),
+            Token::$actual(v),
             v == $v
         );
-    };
-    ($ser:expr, $expected:ident { $($k:ident),* }) => {
+    }};
+    ($ser:expr, $actual:ident { $($k:ident),* }) => {{
         let compare = ($($k,)*);
         let field_format = || {
             use std::fmt::Write;
@@ -55,21 +55,21 @@ macro_rules! assert_next_token {
         };
         assert_next_token!(
             $ser,
-            format_args!(concat!(stringify!($expected), " {{ {}}}"), field_format()),
-            Token::$expected { $($k),* },
+            format_args!(concat!(stringify!($actual), " {{ {}}}"), field_format()),
+            Token::$actual { $($k),* },
             ($($k,)*) == compare
         );
-    };
-    ($ser:expr, $expected:expr, $pat:pat, $guard:expr) => {
+    }};
+    ($ser:expr, $actual:expr, $pat:pat, $guard:expr) => {
         match $ser.next_token() {
             Some($pat) if $guard => {}
-            Some(other) => {
+            Some(expected) => {
                 panic!("expected Token::{} but serialized as {}",
-                       $expected, other);
+                       expected, $actual);
             }
             None => {
-                panic!("expected Token::{} after end of serialized tokens",
-                       $expected);
+                panic!("expected end of tokens, but {} was serialized",
+                       $actual);
             }
         }
     };

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.19", features = ["diff"] }
+trybuild = { version = "1.0.49", 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

@@ -10,7 +10,7 @@ enum DeEnum<B, C, D> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<B, C, D> _serde::Serialize for DeEnum<B, C, D>
@@ -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",
@@ -265,7 +267,7 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, B, C, D> _serde::Deserialize<'de> for DeEnum<B, C, D>
@@ -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",
@@ -573,12 +583,7 @@ 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),
-                                                &"field index 0 <= i < 4",
-                                            ),
-                                        ),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_str<__E>(
@@ -635,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>,
@@ -645,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",
@@ -662,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);
@@ -682,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);
@@ -702,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);
@@ -722,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);
@@ -755,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);
@@ -790,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);
@@ -805,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);
@@ -820,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);
@@ -836,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);
@@ -899,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,
@@ -928,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>,
@@ -938,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",
@@ -955,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);
@@ -975,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);
@@ -995,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);
@@ -1015,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);
@@ -1033,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(
@@ -1062,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",
@@ -1081,12 +1068,7 @@ 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),
-                                                &"field index 0 <= i < 4",
-                                            ),
-                                        ),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_str<__E>(
@@ -1143,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>,
@@ -1153,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",
@@ -1170,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);
@@ -1190,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);
@@ -1210,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);
@@ -1230,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);
@@ -1263,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);
@@ -1298,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);
@@ -1313,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);
@@ -1328,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);
@@ -1344,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);
@@ -1407,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,
@@ -1420,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

@@ -11,7 +11,7 @@ struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> {
@@ -49,11 +49,14 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[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,18 +72,21 @@ 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,
                 {
                     match __value {
                         0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_str<__E>(
@@ -116,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>(
@@ -139,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);
@@ -149,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>(
@@ -165,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) {
@@ -185,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);
@@ -198,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);
@@ -219,7 +233,9 @@ const _: () = {
                             }
                         }
                     };
-                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam {
+                        phantom: __field0,
+                    })
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -252,18 +268,21 @@ 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,
                 {
                     match __value {
                         0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_str<__E>(
@@ -299,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>(
@@ -324,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(())
                 }
@@ -349,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 {
@@ -380,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);
@@ -391,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

@@ -8,7 +8,7 @@ pub enum GenericEnum<T, U> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<T, U> _serde::Serialize for GenericEnum<T, U>
@@ -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,
@@ -114,7 +116,7 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, T, U> _serde::Deserialize<'de> for GenericEnum<T, U>
@@ -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",
@@ -357,12 +386,7 @@ const _: () = {
                                     match __value {
                                         0u64 => _serde::__private::Ok(__Field::__field0),
                                         1u64 => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::__private::Err(
-                                            _serde::de::Error::invalid_value(
-                                                _serde::de::Unexpected::Unsigned(__value),
-                                                &"field index 0 <= i < 2",
-                                            ),
-                                        ),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_str<__E>(
@@ -414,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>,
@@ -423,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",
@@ -440,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);
@@ -450,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);
@@ -465,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 {
@@ -481,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);
@@ -512,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);
@@ -528,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

@@ -5,7 +5,7 @@ pub struct GenericStruct<T> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<T> _serde::Serialize for GenericStruct<T>
@@ -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);
@@ -42,14 +46,16 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, T> _serde::Deserialize<'de> for GenericStruct<T>
     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,18 +71,21 @@ 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,
                 {
                     match __value {
                         0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_str<__E>(
@@ -112,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>
@@ -131,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>(
@@ -141,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);
@@ -150,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 })
@@ -167,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) {
@@ -194,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);
@@ -248,18 +264,21 @@ 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,
                 {
                     match __value {
                         0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_str<__E>(
@@ -295,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>
@@ -305,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>,
             {
@@ -314,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>(
@@ -324,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(())
                 }
@@ -349,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 {
@@ -378,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);
@@ -389,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(())
                 }
             }
@@ -416,7 +445,7 @@ pub struct GenericNewTypeStruct<T>(T);
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<T> _serde::Serialize for GenericNewTypeStruct<T>
@@ -441,14 +470,16 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, T> _serde::Deserialize<'de> for GenericNewTypeStruct<T>
     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>,
         {
@@ -481,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);
@@ -497,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);
@@ -506,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))
@@ -538,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>,
             {
@@ -570,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

@@ -3,7 +3,7 @@ pub struct GenericTupleStruct<T, U>(T, U);
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, T, U> _serde::Deserialize<'de> for GenericTupleStruct<T, U>
@@ -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

@@ -8,7 +8,7 @@ enum Lifetimes<'a> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'a> _serde::Serialize for Lifetimes<'a> {
@@ -95,11 +95,13 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     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",
@@ -244,12 +271,7 @@ const _: () = {
                                 {
                                     match __value {
                                         0u64 => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::__private::Err(
-                                            _serde::de::Error::invalid_value(
-                                                _serde::de::Unexpected::Unsigned(__value),
-                                                &"field index 0 <= i < 1",
-                                            ),
-                                        ),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_str<__E>(
@@ -295,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",
@@ -317,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);
@@ -327,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>(
@@ -340,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);
@@ -370,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);
@@ -392,7 +418,9 @@ const _: () = {
                                             }
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -417,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",
@@ -433,12 +460,7 @@ const _: () = {
                                 {
                                     match __value {
                                         0u64 => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::__private::Err(
-                                            _serde::de::Error::invalid_value(
-                                                _serde::de::Unexpected::Unsigned(__value),
-                                                &"field index 0 <= i < 1",
-                                            ),
-                                        ),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_str<__E>(
@@ -484,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",
@@ -506,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);
@@ -516,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>(
@@ -529,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);
@@ -559,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);
@@ -581,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

@@ -7,7 +7,7 @@ struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedMap<'a, 'b, A, B, C>
@@ -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);
@@ -63,7 +75,7 @@ struct DeNamedMap<A, B, C> {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedMap<A, B, C>
@@ -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,
                 {
@@ -100,10 +120,7 @@ const _: () = {
                         0u64 => _serde::__private::Ok(__Field::__field0),
                         1u64 => _serde::__private::Ok(__Field::__field1),
                         2u64 => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 3",
-                        )),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_str<__E>(
@@ -143,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>
@@ -166,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>(
@@ -176,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);
@@ -185,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);
@@ -200,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);
@@ -215,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 {
@@ -238,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) {
@@ -295,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);
@@ -377,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,
                 {
@@ -387,10 +423,7 @@ const _: () = {
                         0u64 => _serde::__private::Ok(__Field::__field0),
                         1u64 => _serde::__private::Ok(__Field::__field1),
                         2u64 => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 3",
-                        )),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_str<__E>(
@@ -430,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>
@@ -443,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>,
@@ -454,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>(
@@ -464,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(())
                 }
@@ -519,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 {
@@ -582,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);
@@ -593,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

@@ -3,7 +3,7 @@ struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedTuple<'a, 'b, A, B, C>
@@ -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);
@@ -55,7 +64,7 @@ struct DeNamedTuple<A, B, C>(A, B, C);
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedTuple<A, B, C>
@@ -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

@@ -3,7 +3,7 @@ struct NamedUnit;
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl _serde::Serialize for NamedUnit {
@@ -21,11 +21,13 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     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

@@ -13,7 +13,7 @@ where
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'a, B: 'a, C: 'a, D> _serde::Serialize for SerEnum<'a, B, C, D>
@@ -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

@@ -3,7 +3,7 @@ enum Void {}
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
     impl _serde::Serialize for Void {
@@ -21,11 +21,13 @@ const _: () = {
 #[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
 const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
     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,7 +1,12 @@
 #![allow(
     clippy::cast_lossless,
+    clippy::derive_partial_eq_without_eq,
     clippy::from_over_into,
-    clippy::trivially_copy_pass_by_ref
+    // 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::type_repetition_in_bounds
 )]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
@@ -2637,3 +2642,171 @@ fn test_flatten_any_after_flatten_struct() {
         ],
     );
 }
+
+#[test]
+fn test_expecting_message() {
+    #[derive(Deserialize, PartialEq, Debug)]
+    #[serde(expecting = "something strange...")]
+    struct Unit;
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Newtype(bool);
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Tuple(u32, bool);
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Struct {
+        question: String,
+        answer: u32,
+    }
+
+    assert_de_tokens_error::<Unit>(
+        &[Token::Str("Unit")],
+        r#"invalid type: string "Unit", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Newtype>(
+        &[Token::Str("Newtype")],
+        r#"invalid type: string "Newtype", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Tuple>(
+        &[Token::Str("Tuple")],
+        r#"invalid type: string "Tuple", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Struct>(
+        &[Token::Str("Struct")],
+        r#"invalid type: string "Struct", expected something strange..."#,
+    );
+}
+
+#[test]
+fn test_expecting_message_externally_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        ExternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("ExternallyTagged")],
+        r#"invalid type: string "ExternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Enum { name: "Enum" }, Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_internally_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        InternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("InternallyTagged")],
+        r#"invalid type: string "InternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_adjacently_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag", content = "content")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        AdjacentlyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("AdjacentlyTagged")],
+        r#"invalid type: string "AdjacentlyTagged", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Unit],
+        r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_untagged_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        Untagged,
+    }
+
+    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], r#"something strange..."#);
+}
+
+#[test]
+fn test_expecting_message_identifier_enum() {
+    #[derive(Deserialize)]
+    #[serde(field_identifier)]
+    #[serde(expecting = "something strange...")]
+    enum FieldEnum {
+        Field,
+    }
+
+    #[derive(Deserialize)]
+    #[serde(variant_identifier)]
+    #[serde(expecting = "something strange...")]
+    enum VariantEnum {
+        Variant,
+    }
+
+    assert_de_tokens_error::<FieldEnum>(
+        &[Token::Unit],
+        r#"invalid type: unit value, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<FieldEnum>(
+        &[
+            Token::Enum { name: "FieldEnum" },
+            Token::Str("Unknown"),
+            Token::None,
+        ],
+        r#"invalid type: map, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<VariantEnum>(
+        &[Token::Unit],
+        r#"invalid type: unit value, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<VariantEnum>(
+        &[
+            Token::Enum {
+                name: "VariantEnum",
+            },
+            Token::Str("Unknown"),
+            Token::None,
+        ],
+        r#"invalid type: map, expected something strange..."#,
+    );
+}

test_suite/tests/test_borrow.rs

@@ -1,3 +1,9 @@
+#![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};
 
@@ -90,6 +96,30 @@ fn test_struct() {
     );
 }
 
+#[test]
+fn test_field_identifier() {
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldStr<'a> {
+        #[serde(borrow)]
+        Str(&'a str),
+    }
+
+    assert_de_tokens(&FieldStr::Str("value"), &[Token::BorrowedStr("value")]);
+
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldBytes<'a> {
+        #[serde(borrow)]
+        Bytes(&'a [u8]),
+    }
+
+    assert_de_tokens(
+        &FieldBytes::Bytes(b"value"),
+        &[Token::BorrowedBytes(b"value")],
+    );
+}
+
 #[test]
 fn test_cow() {
     #[derive(Deserialize)]

test_suite/tests/test_gen.rs

@@ -3,11 +3,20 @@
 // types involved.
 
 #![deny(warnings)]
-#![cfg_attr(feature = "unstable", feature(non_ascii_idents))]
 #![allow(
     unknown_lints,
     mixed_script_confusables,
-    clippy::trivially_copy_pass_by_ref
+    clippy::derive_partial_eq_without_eq,
+    clippy::items_after_statements,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::must_use_candidate,
+    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
+    clippy::nonstandard_macro_braces,
+    clippy::ptr_arg,
+    clippy::too_many_lines,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
 )]
 
 use serde::de::DeserializeOwned;
@@ -266,7 +275,6 @@ fn test_gen() {
     }
     assert::<EmptyEnumVariant>();
 
-    #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     struct NonAsciiIdents {
         σ: f64,
@@ -642,7 +650,7 @@ fn test_gen() {
     assert::<SkippedVariant<X>>();
 
     #[derive(Deserialize)]
-    struct ImpliciltyBorrowedOption<'a> {
+    struct ImplicitlyBorrowedOption<'a> {
         option: std::option::Option<&'a str>,
     }
 
@@ -723,6 +731,24 @@ fn test_gen() {
     }
 
     deriving!(&'a str);
+
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    #[derive(Deserialize)]
+    struct BorrowLifetimeInsideMacro<'a> {
+        #[serde(borrow = "'a")]
+        f: mac!(Cow<'a, str>),
+    }
+
+    #[derive(Serialize)]
+    struct Struct {
+        #[serde(serialize_with = "vec_first_element")]
+        vec: Vec<Self>,
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -796,3 +822,72 @@ where
 pub fn is_zero(n: &u8) -> bool {
     *n == 0
 }
+
+fn vec_first_element<T, S>(vec: &Vec<T>, serializer: S) -> StdResult<S::Ok, S::Error>
+where
+    T: Serialize,
+    S: Serializer,
+{
+    vec.first().serialize(serializer)
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug, PartialEq, Deserialize)]
+#[serde(tag = "tag")]
+enum InternallyTagged {
+    #[serde(deserialize_with = "deserialize_generic")]
+    Unit,
+
+    #[serde(deserialize_with = "deserialize_generic")]
+    Newtype(i32),
+
+    #[serde(deserialize_with = "deserialize_generic")]
+    Struct { f1: String, f2: u8 },
+}
+
+fn deserialize_generic<'de, T, D>(deserializer: D) -> StdResult<T, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    T::deserialize(deserializer)
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#[repr(packed)]
+pub struct RemotePacked {
+    pub a: u16,
+    pub b: u32,
+}
+
+#[derive(Serialize)]
+#[repr(packed)]
+#[serde(remote = "RemotePacked")]
+pub struct RemotePackedDef {
+    a: u16,
+    b: u32,
+}
+
+impl Drop for RemotePackedDef {
+    fn drop(&mut self) {}
+}
+
+#[repr(packed)]
+pub struct RemotePackedNonCopy {
+    pub a: u16,
+    pub b: String,
+}
+
+#[derive(Deserialize)]
+#[repr(packed)]
+#[serde(remote = "RemotePackedNonCopy")]
+pub struct RemotePackedNonCopyDef {
+    a: u16,
+    b: String,
+}
+
+impl Drop for RemotePackedNonCopyDef {
+    fn drop(&mut self) {}
+}

test_suite/tests/test_identifier.rs

@@ -1,3 +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};
 
@@ -27,6 +31,10 @@ fn test_field_identifier() {
         Bbb,
     }
 
+    assert_de_tokens(&F::Aaa, &[Token::U8(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U16(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U32(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U64(0)]);
     assert_de_tokens(&F::Aaa, &[Token::Str("aaa")]);
     assert_de_tokens(&F::Aaa, &[Token::Bytes(b"aaa")]);
 }
@@ -42,6 +50,10 @@ fn test_unit_fallthrough() {
         Other,
     }
 
+    assert_de_tokens(&F::Other, &[Token::U8(42)]);
+    assert_de_tokens(&F::Other, &[Token::U16(42)]);
+    assert_de_tokens(&F::Other, &[Token::U32(42)]);
+    assert_de_tokens(&F::Other, &[Token::U64(42)]);
     assert_de_tokens(&F::Other, &[Token::Str("x")]);
 }
 
@@ -68,5 +80,9 @@ fn test_newtype_fallthrough_generic() {
         Other(T),
     }
 
+    assert_de_tokens(&F::Other(42u8), &[Token::U8(42)]);
+    assert_de_tokens(&F::Other(42u16), &[Token::U16(42)]);
+    assert_de_tokens(&F::Other(42u32), &[Token::U32(42)]);
+    assert_de_tokens(&F::Other(42u64), &[Token::U64(42)]);
     assert_de_tokens(&F::Other("x".to_owned()), &[Token::Str("x")]);
 }

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,10 @@
 #![deny(trivial_numeric_casts)]
-#![allow(clippy::redundant_field_names)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::enum_variant_names,
+    clippy::redundant_field_names,
+    clippy::too_many_lines
+)]
 
 mod bytes;
 
@@ -994,6 +999,28 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
             Token::StructEnd,
         ],
     );
+
+    assert_de_tokens(
+        &Message::Log { level: Level::Info },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("action"),
+            Token::Str("Log"),
+            Token::Str("level"),
+            Token::BorrowedStr("Info"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Message::Log { level: Level::Info },
+        &[
+            Token::Seq { len: Some(2) },
+            Token::Str("Log"),
+            Token::BorrowedStr("Info"),
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
@@ -1877,9 +1904,31 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
             Token::MapEnd,
         ],
     );
+
+    assert_de_tokens(
+        &Message::Info(Info),
+        &[
+            Token::Struct {
+                name: "Message",
+                len: 1,
+            },
+            Token::Str("topic"),
+            Token::Str("Info"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Message::Info(Info),
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Str("Info"),
+            Token::SeqEnd,
+        ],
+    );
 }
 
-#[deny(safe_packed_borrows)]
+#[deny(unaligned_references)]
 #[test]
 fn test_packed_struct_can_derive_serialize() {
     #[derive(Copy, Clone, Serialize)]

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_self.rs

@@ -0,0 +1,88 @@
+#![allow(clippy::used_underscore_binding)]
+
+use serde::{Deserialize, Serialize};
+
+#[test]
+fn test_self() {
+    pub trait Trait {
+        type Assoc;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    pub struct Generics<T: Trait<Assoc = Self>>
+    where
+        Self: Trait<Assoc = Self>,
+        <Self as Trait>::Assoc: Sized,
+    {
+        _f: T,
+    }
+
+    impl<T: Trait<Assoc = Self>> Trait for Generics<T> {
+        type Assoc = Self;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    pub struct Struct {
+        _f1: Box<Self>,
+        _f2: Box<<Self as Trait>::Assoc>,
+        _f4: [(); Self::ASSOC],
+        _f5: [(); Self::assoc()],
+    }
+
+    impl Struct {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Struct {
+        type Assoc = Self;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    struct Tuple(
+        Box<Self>,
+        Box<<Self as Trait>::Assoc>,
+        [(); Self::ASSOC],
+        [(); Self::assoc()],
+    );
+
+    impl Tuple {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Tuple {
+        type Assoc = Self;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    enum Enum {
+        Struct {
+            _f1: Box<Self>,
+            _f2: Box<<Self as Trait>::Assoc>,
+            _f4: [(); Self::ASSOC],
+            _f5: [(); Self::assoc()],
+        },
+        Tuple(
+            Box<Self>,
+            Box<<Self as Trait>::Assoc>,
+            [(); Self::ASSOC],
+            [(); Self::assoc()],
+        ),
+    }
+
+    impl Enum {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Enum {
+        type Assoc = Self;
+    }
+}

test_suite/tests/test_serde_path.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_repetition_in_bounds)]
+
 #[test]
 fn test_gen_custom_serde() {
     #[derive(serde::Serialize, serde::Deserialize)]

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,3 +1,5 @@
+#![allow(clippy::derive_partial_eq_without_eq, clippy::similar_names)]
+
 use serde::de::value::{self, MapAccessDeserializer};
 use serde::de::{IntoDeserializer, MapAccess, Visitor};
 use serde::{Deserialize, Deserializer};
@@ -17,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/borrow/bad_lifetimes.stderr

@@ -1,5 +1,5 @@
 error: failed to parse borrowed lifetimes: "zzz"
- --> $DIR/bad_lifetimes.rs:5:22
+ --> tests/ui/borrow/bad_lifetimes.rs:5:22
   |
 5 |     #[serde(borrow = "zzz")]
   |                      ^^^^^

test_suite/tests/ui/borrow/duplicate_lifetime.stderr

@@ -1,5 +1,5 @@
 error: duplicate borrowed lifetime `'a`
- --> $DIR/duplicate_lifetime.rs:5:22
+ --> tests/ui/borrow/duplicate_lifetime.rs:5:22
   |
 5 |     #[serde(borrow = "'a + 'a")]
   |                      ^^^^^^^^^

test_suite/tests/ui/borrow/duplicate_variant.stderr

@@ -1,5 +1,5 @@
 error: duplicate serde attribute `borrow`
- --> $DIR/duplicate_variant.rs:8:13
+ --> tests/ui/borrow/duplicate_variant.rs:8:13
   |
 8 |     #[serde(borrow)]
   |             ^^^^^^

test_suite/tests/ui/borrow/empty_lifetimes.stderr

@@ -1,5 +1,5 @@
 error: at least one lifetime must be borrowed
- --> $DIR/empty_lifetimes.rs:5:22
+ --> tests/ui/borrow/empty_lifetimes.rs:5:22
   |
 5 |     #[serde(borrow = "")]
   |                      ^^

test_suite/tests/ui/borrow/no_lifetimes.stderr

@@ -1,5 +1,5 @@
 error: field `s` has no lifetimes to borrow
- --> $DIR/no_lifetimes.rs:5:5
+ --> tests/ui/borrow/no_lifetimes.rs:5:5
   |
 5 | /     #[serde(borrow)]
 6 | |     s: String,

test_suite/tests/ui/borrow/struct_variant.stderr

@@ -1,5 +1,5 @@
 error: #[serde(borrow)] may only be used on newtype variants
- --> $DIR/struct_variant.rs:8:5
+ --> tests/ui/borrow/struct_variant.rs:8:5
   |
 8 | /     #[serde(borrow)]
 9 | |     S { s: Str<'a> },

test_suite/tests/ui/borrow/wrong_lifetime.stderr

@@ -1,5 +1,5 @@
 error: field `s` does not have lifetime 'b
- --> $DIR/wrong_lifetime.rs:5:5
+ --> tests/ui/borrow/wrong_lifetime.rs:5:5
   |
 5 | /     #[serde(borrow = "'b")]
 6 | |     s: &'a str,

test_suite/tests/ui/conflict/adjacent-tag.stderr

@@ -1,5 +1,5 @@
 error: enum tags `conflict` for type and content conflict with each other
- --> $DIR/adjacent-tag.rs:4:1
+ --> tests/ui/conflict/adjacent-tag.rs:4:1
   |
 4 | / #[serde(tag = "conflict", content = "conflict")]
 5 | | enum E {

test_suite/tests/ui/conflict/flatten-newtype-struct.stderr

@@ -1,5 +1,5 @@
 error: #[serde(flatten)] cannot be used on newtype structs
- --> $DIR/flatten-newtype-struct.rs:6:12
+ --> tests/ui/conflict/flatten-newtype-struct.rs:6:12
   |
 6 | struct Foo(#[serde(flatten)] HashMap<String, String>);
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

test_suite/tests/ui/conflict/flatten-tuple-struct.stderr

@@ -1,5 +1,5 @@
 error: #[serde(flatten)] cannot be used on tuple structs
- --> $DIR/flatten-tuple-struct.rs:6:17
+ --> tests/ui/conflict/flatten-tuple-struct.rs:6:17
   |
 6 | struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

test_suite/tests/ui/conflict/from-try-from.stderr

@@ -1,5 +1,5 @@
 error: #[serde(from = "...")] and #[serde(try_from = "...")] conflict with each other
- --> $DIR/from-try-from.rs:4:1
+ --> tests/ui/conflict/from-try-from.rs:4:1
   |
 4 | / #[serde(from = "u64", try_from = "u64")]
 5 | | struct S {

test_suite/tests/ui/conflict/internal-tag-alias.stderr

@@ -1,5 +1,5 @@
 error: variant field name `conflict` conflicts with internal tag
-  --> $DIR/internal-tag-alias.rs:4:1
+  --> tests/ui/conflict/internal-tag-alias.rs:4:1
    |
 4  | / #[serde(tag = "conflict")]
 5  | | enum E {

test_suite/tests/ui/conflict/internal-tag.stderr

@@ -1,5 +1,5 @@
 error: variant field name `conflict` conflicts with internal tag
-  --> $DIR/internal-tag.rs:4:1
+  --> tests/ui/conflict/internal-tag.rs:4:1
    |
 4  | / #[serde(tag = "conflict")]
 5  | | enum E {

test_suite/tests/ui/default-attribute/enum.stderr

@@ -1,5 +1,5 @@
 error: #[serde(default)] can only be used on structs with named fields
- --> $DIR/enum.rs:5:1
+ --> tests/ui/default-attribute/enum.rs:5:1
   |
 5 | enum E {
   | ^^^^

test_suite/tests/ui/default-attribute/enum_path.stderr

@@ -1,5 +1,5 @@
 error: #[serde(default = "...")] can only be used on structs with named fields
- --> $DIR/enum_path.rs:5:1
+ --> tests/ui/default-attribute/enum_path.rs:5:1
   |
 5 | enum E {
   | ^^^^