Release 1.0.165

error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
       --> test_suite/tests/test_de.rs:202:12
        |
    202 |     .chain(vec![Token::MapEnd].into_iter())
        |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![Token::MapEnd]`
        |
    note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
       --> /home/david/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:522:12
        |
    522 |         U: IntoIterator<Item = Self::Item>,
        |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
        = note: `-D clippy::useless-conversion` implied by `-D clippy::all`

.gitattributes

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

.github/workflows/ci.yml

@@ -3,8 +3,12 @@ name: CI
 on:
   push:
   pull_request:
+  workflow_dispatch:
   schedule: [cron: "40 1 * * *"]
 
+permissions:
+  contents: read
+
 env:
   RUSTFLAGS: -Dwarnings
 
@@ -12,18 +16,16 @@ jobs:
   test:
     name: Test suite
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable
-      - uses: dtolnay/install@cargo-expand
-        if: github.event_name != 'pull_request'
-      - run: cd test_suite && cargo test --features expandtest --test expandtest -- --include-ignored
-        if: github.event_name != 'pull_request'
 
   windows:
     name: Test suite (windows)
     runs-on: windows-latest
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
@@ -36,6 +38,7 @@ jobs:
       fail-fast: false
       matrix:
         rust: [stable, beta]
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
@@ -53,6 +56,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu, windows]
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
@@ -68,23 +72,6 @@ jobs:
           RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
         if: matrix.os != 'windows'
 
-  msrv:
-    name: Rust 1.13.0
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@1.13.0
-      - name: Get timestamp for cache
-        id: date
-        run: echo ::set-output name=yearmo::$(date +%Y%m)
-      - uses: actions/cache@v1
-        with:
-          path: ~/.cargo/registry/index
-          key: cargo-registry-index-${{steps.date.outputs.yearmo}}
-      - run: cd serde && cargo build --features rc
-      - run: cd serde && cargo build --no-default-features
-      - run: cd serde_test && cargo build
-
   build:
     name: Rust ${{matrix.rust}}
     runs-on: ubuntu-latest
@@ -92,13 +79,16 @@ jobs:
       fail-fast: false
       matrix:
         rust: [1.19.0, 1.20.0, 1.21.0, 1.25.0, 1.26.0, 1.34.0]
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@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 && cargo build
+      - run: cd serde_test && cargo build
 
   more:
     name: Rust ${{matrix.rust}}
@@ -107,6 +97,7 @@ jobs:
       fail-fast: false
       matrix:
         rust: [1.27.0, 1.28.0]
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
@@ -118,11 +109,12 @@ jobs:
       - run: cd serde && cargo build
 
   derive:
-    name: Rust 1.31.0
+    name: Rust 1.56.0
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@1.31.0
+      - uses: dtolnay/rust-toolchain@1.56.0
       - run: cd serde && cargo check --no-default-features
       - run: cd serde && cargo check
       - run: cd serde_derive && cargo check
@@ -130,37 +122,17 @@ jobs:
   alloc:
     name: Rust 1.36.0
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.36.0
       - run: cd serde && cargo build --no-default-features --features alloc
 
-  emscripten:
-    name: Emscripten
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@nightly
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 9
-      - name: Install cargo-web
-        run: |
-          CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
-          CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
-          CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
-          mkdir -p ~/.cargo/bin
-          curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
-          chmod +x ~/.cargo/bin/cargo-web
-      - run: cd test_suite && cargo web test --target=asmjs-unknown-emscripten --nodejs
-        continue-on-error: true
-      - run: cd test_suite && cargo web test --target=wasm32-unknown-emscripten --nodejs
-        continue-on-error: true
-
   clippy:
     name: Clippy
     runs-on: ubuntu-latest
     if: github.event_name != 'pull_request'
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@clippy
@@ -174,9 +146,11 @@ jobs:
   miri:
     name: Miri
     runs-on: ubuntu-latest
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@miri
+      - run: cargo miri setup
       - run: cd serde && cargo miri test --features derive,rc,unstable
         env:
           MIRIFLAGS: -Zmiri-strict-provenance
@@ -188,7 +162,8 @@ jobs:
     name: Outdated
     runs-on: ubuntu-latest
     if: github.event_name != 'pull_request'
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/install@cargo-outdated
-      - run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1
+      - run: cargo outdated --workspace --exit-code 1

LICENSE-APACHE

@@ -174,28 +174,3 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
    of your accepting any such warranty or additional liability.
 
 END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

README.md

@@ -1,13 +1,13 @@
-# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
+# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![serde_derive: rustc 1.56+]][Rust 1.56]
 
-[Build Status]: https://img.shields.io/github/workflow/status/serde-rs/serde/CI/master
+[Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master
 [actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
 [Latest Version]: https://img.shields.io/crates/v/serde.svg
 [crates.io]: https://crates.io/crates/serde
-[serde: rustc 1.13+]: https://img.shields.io/badge/serde-rustc_1.13+-lightgray.svg
-[serde_derive: rustc 1.31+]: https://img.shields.io/badge/serde_derive-rustc_1.31+-lightgray.svg
-[Rust 1.13]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
-[Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
+[serde: rustc 1.19+]: https://img.shields.io/badge/serde-rustc_1.19+-lightgray.svg
+[serde_derive: rustc 1.56+]: https://img.shields.io/badge/serde_derive-rustc_1.56+-lightgray.svg
+[Rust 1.19]: https://blog.rust-lang.org/2017/07/20/Rust-1.19.html
+[Rust 1.56]: https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html
 
 **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
 
@@ -19,7 +19,7 @@ You may be looking for:
 - [Data formats supported by Serde](https://serde.rs/#data-formats)
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
 - [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.serde.rs/serde/)
+- [API documentation](https://docs.rs/serde)
 - [Release notes](https://github.com/serde-rs/serde/releases)
 
 ## Serde in action

crates-io.md

@@ -10,7 +10,7 @@ You may be looking for:
 - [Data formats supported by Serde](https://serde.rs/#data-formats)
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
 - [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.serde.rs/serde/)
+- [API documentation](https://docs.rs/serde)
 - [Release notes](https://github.com/serde-rs/serde/releases)
 
 ## Serde in action

serde/.clippy.toml

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

serde/Cargo.toml

@@ -1,29 +1,33 @@
 [package]
 name = "serde"
-version = "1.0.140" # remember to update html_root_url and serde_derive dependency
+version = "1.0.165" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.13"
-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.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.19"
 
 [dependencies]
-serde_derive = { version = "=1.0.140", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.165", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }
 
+[lib]
+doc-scrape-examples = false
+
 [package.metadata.playground]
 features = ["derive", "rc"]
 
 [package.metadata.docs.rs]
+features = ["derive"]
 targets = ["x86_64-unknown-linux-gnu"]
 
 

serde/build.rs

@@ -6,6 +6,8 @@ use std::str::{self, FromStr};
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
     let minor = match rustc_minor_version() {
         Some(minor) => minor,
         None => return,
@@ -76,11 +78,6 @@ fn main() {
         println!("cargo:rustc-cfg=no_num_nonzero");
     }
 
-    // Current minimum supported version of serde_derive crate is Rust 1.31.
-    if minor < 31 {
-        println!("cargo:rustc-cfg=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
@@ -89,24 +86,39 @@ fn main() {
         println!("cargo:rustc-cfg=no_core_try_from");
         println!("cargo:rustc-cfg=no_num_nonzero_signed");
         println!("cargo:rustc-cfg=no_systemtime_checked_add");
+        println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
     }
 
-    // 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");
+    // Current minimum supported version of serde_derive crate is Rust 1.56.
+    if minor < 56 {
+        println!("cargo:rustc-cfg=no_serde_derive");
     }
-    if minor < 34 || !has_atomic32 {
-        println!("cargo:rustc-cfg=no_std_atomic");
+
+    // Support for #[cfg(target_has_atomic = "...")] stabilized in Rust 1.60.
+    if minor < 60 {
+        println!("cargo:rustc-cfg=no_target_has_atomic");
+        // Allowlist of archs that support std::sync::atomic module. 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");
+        }
+    }
+
+    // Support for core::ffi::CStr and alloc::ffi::CString stabilized in Rust 1.64.
+    // https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html#c-compatible-ffi-types-in-core-and-alloc
+    if minor < 64 {
+        println!("cargo:rustc-cfg=no_core_cstr");
     }
 }
 

serde/src/de/format.rs

@@ -1,7 +1,7 @@
 use lib::fmt::{self, Write};
 use lib::str;
 
-pub struct Buf<'a> {
+pub(super) struct Buf<'a> {
     bytes: &'a mut [u8],
     offset: usize,
 }

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

@@ -666,10 +666,10 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 struct CStringVisitor;
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 impl<'de> Visitor<'de> for CStringVisitor {
     type Value = CString;
 
@@ -720,7 +720,7 @@ impl<'de> Visitor<'de> for CStringVisitor {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 impl<'de> Deserialize<'de> for CString {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -733,7 +733,7 @@ impl<'de> Deserialize<'de> for CString {
 macro_rules! forwarded_impl {
     (
         $(#[doc = $doc:tt])*
-        ( $($id: ident),* ), $ty: ty, $func: expr
+        ($($id:ident),*), $ty:ty, $func:expr
     ) => {
         $(#[doc = $doc])*
         impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
@@ -747,7 +747,10 @@ macro_rules! forwarded_impl {
     }
 }
 
-#[cfg(all(feature = "std", not(no_de_boxed_c_str)))]
+#[cfg(all(
+    any(feature = "std", all(not(no_core_cstr), feature = "alloc")),
+    not(no_de_boxed_c_str)
+))]
 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
 
 #[cfg(not(no_core_reverse))]
@@ -860,7 +863,7 @@ impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
 #[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! seq_impl {
     (
-        $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
+        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
         $access:ident,
         $clear:expr,
         $with_capacity:expr,
@@ -991,7 +994,8 @@ seq_impl!(
     HashSet::clear,
     HashSet::with_capacity_and_hasher(size_hint::cautious(seq.size_hint()), S::default()),
     HashSet::reserve,
-    HashSet::insert);
+    HashSet::insert
+);
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(
@@ -1353,7 +1357,7 @@ tuple_impls! {
 #[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! map_impl {
     (
-        $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
+        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
         $access:ident,
         $with_capacity:expr
     ) => {
@@ -1406,16 +1410,14 @@ macro_rules! map_impl {
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-map_impl!(
-    BTreeMap<K: Ord, V>,
-    map,
-    BTreeMap::new());
+map_impl!(BTreeMap<K: Ord, V>, map, BTreeMap::new());
 
 #[cfg(feature = "std")]
 map_impl!(
     HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
     map,
-    HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default()));
+    HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default())
+);
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -1440,15 +1442,15 @@ macro_rules! parse_ip_impl {
 #[cfg(feature = "std")]
 macro_rules! variant_identifier {
     (
-        $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
-        $expecting_message: expr,
-        $variants_name: ident
+        $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*)
+        $expecting_message:expr,
+        $variants_name:ident
     ) => {
         enum $name_kind {
-            $( $variant ),*
+            $($variant),*
         }
 
-        static $variants_name: &'static [&'static str] = &[ $( stringify!($variant) ),*];
+        static $variants_name: &'static [&'static str] = &[$(stringify!($variant)),*];
 
         impl<'de> Deserialize<'de> for $name_kind {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1515,12 +1517,12 @@ macro_rules! variant_identifier {
 #[cfg(feature = "std")]
 macro_rules! deserialize_enum {
     (
-        $name: ident $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
-        $expecting_message: expr,
-        $deserializer: expr
+        $name:ident $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*)
+        $expecting_message:expr,
+        $deserializer:expr
     ) => {
-        variant_identifier!{
-            $name_kind ( $($variant; $bytes; $index),* )
+        variant_identifier! {
+            $name_kind ($($variant; $bytes; $index),*)
             $expecting_message,
             VARIANTS
         }
@@ -1585,7 +1587,7 @@ macro_rules! parse_socket_impl {
                 if deserializer.is_human_readable() {
                     deserializer.deserialize_str(FromStrVisitor::new($expecting))
                 } else {
-                    <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
+                    <(_, u16)>::deserialize(deserializer).map($new)
                 }
             }
         }
@@ -1612,12 +1614,10 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
 }
 
 #[cfg(feature = "std")]
-parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
+parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, |(ip, port)| net::SocketAddrV4::new(ip, port));
 
 #[cfg(feature = "std")]
-parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
-    ip, port, 0, 0
-));
+parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |(ip, port)| net::SocketAddrV6::new(ip, port, 0, 0));
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -2096,7 +2096,7 @@ impl<'de> Deserialize<'de> for Duration {
             }
         }
 
-        const FIELDS: &'static [&'static str] = &["secs", "nanos"];
+        const FIELDS: &[&str] = &["secs", "nanos"];
         deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
     }
 }
@@ -2238,7 +2238,7 @@ impl<'de> Deserialize<'de> for SystemTime {
             }
         }
 
-        const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
+        const FIELDS: &[&str] = &["secs_since_epoch", "nanos_since_epoch"];
         let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
         #[cfg(not(no_systemtime_checked_add))]
         let ret = UNIX_EPOCH
@@ -2268,14 +2268,14 @@ 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)
     }
 }
@@ -2289,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))
     }
 }
@@ -2306,7 +2306,7 @@ mod range {
 
     use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 
-    pub const FIELDS: &'static [&'static str] = &["start", "end"];
+    pub const FIELDS: &[&str] = &["start", "end"];
 
     // If this were outside of the serde crate, it would just use:
     //
@@ -2532,7 +2532,7 @@ where
             }
         }
 
-        const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
+        const VARIANTS: &[&str] = &["Unbounded", "Included", "Excluded"];
 
         deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
     }
@@ -2640,7 +2640,7 @@ where
             }
         }
 
-        const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
+        const VARIANTS: &[&str] = &["Ok", "Err"];
 
         deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
     }
@@ -2662,8 +2662,9 @@ where
 
 #[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
-    ($($ty:ident)*) => {
+    ($($ty:ident $size:expr)*) => {
         $(
+            #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
             impl<'de> Deserialize<'de> for $ty {
                 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                 where
@@ -2678,14 +2679,21 @@ macro_rules! atomic_impl {
 
 #[cfg(all(feature = "std", not(no_std_atomic)))]
 atomic_impl! {
-    AtomicBool
-    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
-    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+    AtomicBool "8"
+    AtomicI8 "8"
+    AtomicI16 "16"
+    AtomicI32 "32"
+    AtomicIsize "ptr"
+    AtomicU8 "8"
+    AtomicU16 "16"
+    AtomicU32 "32"
+    AtomicUsize "ptr"
 }
 
 #[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
-    AtomicI64 AtomicU64
+    AtomicI64 "64"
+    AtomicU64 "64"
 }
 
 #[cfg(feature = "std")]
@@ -2698,7 +2706,7 @@ struct FromStrVisitor<T> {
 impl<T> FromStrVisitor<T> {
     fn new(expecting: &'static str) -> Self {
         FromStrVisitor {
-            expecting: expecting,
+            expecting,
             ty: PhantomData,
         }
     }

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/bincode-org/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
@@ -501,8 +501,8 @@ impl<'a> Display for Expected + 'a {
 /// by Serde.
 ///
 /// Serde provides `Deserialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][de]. All of these can
-/// be deserialized using Serde out of the box.
+/// standard library types. The complete list is [here][crate::de]. All of these
+/// can be deserialized using Serde out of the box.
 ///
 /// Additionally, Serde provides a procedural macro called `serde_derive` to
 /// automatically generate `Deserialize` implementations for structs and enums
@@ -518,7 +518,6 @@ impl<'a> Display for Expected + 'a {
 /// `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate
 /// provides an implementation of `Deserialize` for it.
 ///
-/// [de]: https://docs.serde.rs/serde/de/index.html
 /// [derive]: https://serde.rs/derive.html
 /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
 ///
@@ -565,7 +564,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(())
     }
 }
@@ -862,10 +861,10 @@ where
 /// The `Deserializer` trait supports two entry point styles which enables
 /// different kinds of deserialization.
 ///
-/// 1. The `deserialize` method. Self-describing data formats like JSON are able
-///    to look at the serialized data and tell what it represents. For example
-///    the JSON deserializer may see an opening curly brace (`{`) and know that
-///    it is seeing a map. If the data format supports
+/// 1. The `deserialize_any` method. Self-describing data formats like JSON are
+///    able to look at the serialized data and tell what it represents. For
+///    example the JSON deserializer may see an opening curly brace (`{`) and
+///    know that it is seeing a map. If the data format supports
 ///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever
 ///    type it sees in the input. JSON uses this approach when deserializing
 ///    `serde_json::Value` which is an enum that can represent any JSON
@@ -874,7 +873,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
@@ -884,7 +883,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
@@ -915,7 +914,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
@@ -1156,7 +1155,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
@@ -1560,7 +1559,7 @@ pub trait Visitor<'de>: Sized {
     /// `Deserializer`.
     ///
     /// This enables zero-copy deserialization of bytes in some formats. For
-    /// example Bincode data containing bytes can be deserialized with zero
+    /// example Postcard data containing bytes can be deserialized with zero
     /// copying into a `&'a [u8]` as long as the input data outlives `'a`.
     ///
     /// The default implementation forwards to `visit_bytes`.

serde/src/de/utf8.rs

@@ -31,7 +31,7 @@ pub fn encode(c: char) -> Encode {
         buf[3] = (code & 0x3F) as u8 | TAG_CONT;
         0
     };
-    Encode { buf: buf, pos: pos }
+    Encode { buf, pos }
 }
 
 pub struct Encode {

serde/src/de/value.rs

@@ -251,7 +251,7 @@ macro_rules! primitive_deserializer {
             #[allow(missing_docs)]
             pub fn new(value: $ty) -> Self {
                 $name {
-                    value: value,
+                    value,
                     marker: PhantomData,
                 }
             }
@@ -330,7 +330,7 @@ impl<E> U32Deserializer<E> {
     #[allow(missing_docs)]
     pub fn new(value: u32) -> Self {
         U32Deserializer {
-            value: value,
+            value,
             marker: PhantomData,
         }
     }
@@ -419,7 +419,7 @@ impl<'a, E> StrDeserializer<'a, E> {
     #[allow(missing_docs)]
     pub fn new(value: &'a str) -> Self {
         StrDeserializer {
-            value: value,
+            value,
             marker: PhantomData,
         }
     }
@@ -498,7 +498,7 @@ impl<'de, E> BorrowedStrDeserializer<'de, E> {
     /// Create a new borrowed deserializer from the given string.
     pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
         BorrowedStrDeserializer {
-            value: value,
+            value,
             marker: PhantomData,
         }
     }
@@ -598,7 +598,7 @@ impl<E> StringDeserializer<E> {
     #[allow(missing_docs)]
     pub fn new(value: String) -> Self {
         StringDeserializer {
-            value: value,
+            value,
             marker: PhantomData,
         }
     }
@@ -701,7 +701,7 @@ impl<'a, E> CowStrDeserializer<'a, E> {
     #[allow(missing_docs)]
     pub fn new(value: Cow<'a, str>) -> Self {
         CowStrDeserializer {
-            value: value,
+            value,
             marker: PhantomData,
         }
     }
@@ -783,7 +783,7 @@ impl<'a, E> BytesDeserializer<'a, E> {
     /// Create a new deserializer from the given bytes.
     pub fn new(value: &'a [u8]) -> Self {
         BytesDeserializer {
-            value: value,
+            value,
             marker: PhantomData,
         }
     }
@@ -842,7 +842,7 @@ 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,
+            value,
             marker: PhantomData,
         }
     }
@@ -1053,7 +1053,7 @@ pub struct SeqAccessDeserializer<A> {
 impl<A> SeqAccessDeserializer<A> {
     /// Construct a new `SeqAccessDeserializer<A>`.
     pub fn new(seq: A) -> Self {
-        SeqAccessDeserializer { seq: seq }
+        SeqAccessDeserializer { seq }
     }
 }
 
@@ -1454,7 +1454,7 @@ pub struct MapAccessDeserializer<A> {
 impl<A> MapAccessDeserializer<A> {
     /// Construct a new `MapAccessDeserializer<A>`.
     pub fn new(map: A) -> Self {
-        MapAccessDeserializer { map: map }
+        MapAccessDeserializer { map }
     }
 }
 
@@ -1501,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")),
         }
@@ -1510,6 +1510,41 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+/// A deserializer holding an `EnumAccess`.
+#[derive(Clone, Debug)]
+pub struct EnumAccessDeserializer<A> {
+    access: A,
+}
+
+impl<A> EnumAccessDeserializer<A> {
+    /// Construct a new `EnumAccessDeserializer<A>`.
+    pub fn new(access: A) -> Self {
+        EnumAccessDeserializer { access }
+    }
+}
+
+impl<'de, A> de::Deserializer<'de> for EnumAccessDeserializer<A>
+where
+    A: de::EnumAccess<'de>,
+{
+    type Error = A::Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_enum(self.access)
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 mod private {
     use lib::*;
 
@@ -1578,7 +1613,7 @@ mod private {
     }
 
     pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
-        MapAsEnum { map: map }
+        MapAsEnum { map }
     }
 
     impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
@@ -1602,10 +1637,7 @@ mod private {
         where
             V: Visitor<'de>,
         {
-            self.map.next_value_seed(SeedTupleVariant {
-                len: len,
-                visitor: visitor,
-            })
+            self.map.next_value_seed(SeedTupleVariant { len, visitor })
         }
 
         fn struct_variant<V>(
@@ -1616,8 +1648,7 @@ mod private {
         where
             V: Visitor<'de>,
         {
-            self.map
-                .next_value_seed(SeedStructVariant { visitor: visitor })
+            self.map.next_value_seed(SeedStructVariant { visitor })
         }
     }
 

serde/src/lib.rs

@@ -31,8 +31,7 @@
 //! for Serde by the community.
 //!
 //! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.
-//! - [Bincode], a compact binary format
-//!   used for IPC within the Servo rendering engine.
+//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
 //! - [CBOR], a Concise Binary Object Representation designed for small message
 //!   size without the need for version negotiation.
 //! - [YAML], a self-proclaimed human-friendly configuration language that ain't
@@ -45,8 +44,9 @@
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
 //! - [JSON5], a superset of JSON including some productions from ES5.
-//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
 //! - [URL] query strings, in the x-www-form-urlencoded format.
+//! - [Starlark], the format used for describing build targets by the Bazel and
+//!   Buck build systems. *(serialization only)*
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(deserialization only)*
 //! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
@@ -54,23 +54,29 @@
 //! - [S-expressions], the textual representation of code and data used by the
 //!   Lisp language family.
 //! - [D-Bus]'s binary wire format.
-//! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.
+//! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy
+//!   serialization format.
+//! - [Bencode], a simple binary format used in the BitTorrent protocol.
+//! - [Token streams], for processing Rust procedural macro input.
+//!   *(deserialization only)*
 //! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
 //!   and from DynamoDB.
+//! - [Hjson], a syntax extension to JSON designed around human reading and
+//!   editing. *(deserialization only)*
 //!
 //! [JSON]: https://github.com/serde-rs/json
-//! [Bincode]: https://github.com/bincode-org/bincode
+//! [Postcard]: https://github.com/jamesmunns/postcard
 //! [CBOR]: https://github.com/enarx/ciborium
 //! [YAML]: https://github.com/dtolnay/serde-yaml
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
-//! [TOML]: https://github.com/alexcrichton/toml-rs
+//! [TOML]: https://docs.rs/toml
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [RON]: https://github.com/ron-rs/ron
 //! [BSON]: https://github.com/mongodb/bson-rust
-//! [Avro]: https://github.com/flavray/avro-rs
+//! [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
+//! [Starlark]: https://github.com/dtolnay/serde-starlark
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -78,20 +84,23 @@
 //! [S-expressions]: https://github.com/rotty/lexpr-rs
 //! [D-Bus]: https://docs.rs/zvariant
 //! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
+//! [Bencode]: https://github.com/P3KI/bendy
+//! [Token streams]: https://github.com/oxidecomputer/serde_tokenstream
 //! [DynamoDB Items]: https://docs.rs/serde_dynamo
 //! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
+//! [Hjson]: https://github.com/Canop/deser-hjson
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.140")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.165")]
 // 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
 // discussion of these features please refer to this issue:
 //
 //    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(never_type))]
+#![cfg_attr(feature = "unstable", feature(error_in_core, never_type))]
 #![allow(unknown_lints, bare_trait_objects, deprecated)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 // Ignored clippy and clippy_pedantic lints
@@ -121,7 +130,7 @@
         derive_partial_eq_without_eq,
         enum_glob_use,
         explicit_auto_deref,
-        let_underscore_drop,
+        let_underscore_untyped,
         map_err_ignore,
         new_without_default,
         result_unit_err,
@@ -210,13 +219,23 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
 
+    #[cfg(all(not(no_core_cstr), not(feature = "std")))]
+    pub use core::ffi::CStr;
+    #[cfg(feature = "std")]
+    pub use std::ffi::CStr;
+
+    #[cfg(all(not(no_core_cstr), feature = "alloc", not(feature = "std")))]
+    pub use alloc::ffi::CString;
+    #[cfg(feature = "std")]
+    pub use std::ffi::CString;
+
     #[cfg(feature = "std")]
     pub use std::{error, net};
 
     #[cfg(feature = "std")]
     pub use std::collections::{HashMap, HashSet};
     #[cfg(feature = "std")]
-    pub use std::ffi::{CStr, CString, OsStr, OsString};
+    pub use std::ffi::{OsStr, OsString};
     #[cfg(feature = "std")]
     pub use std::hash::{BuildHasher, Hash};
     #[cfg(feature = "std")]
@@ -240,18 +259,44 @@ mod lib {
     #[cfg(not(no_range_inclusive))]
     pub use self::core::ops::RangeInclusive;
 
-    #[cfg(all(feature = "std", not(no_std_atomic)))]
+    #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic)))]
     pub use std::sync::atomic::{
         AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
         AtomicUsize, Ordering,
     };
-    #[cfg(all(feature = "std", not(no_std_atomic64)))]
+    #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic64)))]
     pub use std::sync::atomic::{AtomicI64, AtomicU64};
 
+    #[cfg(all(feature = "std", not(no_target_has_atomic)))]
+    pub use std::sync::atomic::Ordering;
+    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "8"))]
+    pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
+    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "16"))]
+    pub use std::sync::atomic::{AtomicI16, AtomicU16};
+    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "32"))]
+    pub use std::sync::atomic::{AtomicI32, AtomicU32};
+    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "64"))]
+    pub use std::sync::atomic::{AtomicI64, AtomicU64};
+    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))]
+    pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
+
     #[cfg(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]
@@ -281,7 +326,7 @@ use self::__private as private;
 #[path = "de/seed.rs"]
 mod seed;
 
-#[cfg(not(feature = "std"))]
+#[cfg(not(any(feature = "std", feature = "unstable")))]
 mod std_error;
 
 // Re-export #[derive(Serialize, Deserialize)].
@@ -293,9 +338,10 @@ mod std_error;
 #[allow(unused_imports)]
 #[macro_use]
 extern crate serde_derive;
+
+/// Derive macro available if serde is built with `features = ["derive"]`.
 #[cfg(feature = "serde_derive")]
-#[doc(hidden)]
-pub use serde_derive::*;
+pub use serde_derive::{Deserialize, Serialize};
 
 #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
 mod actually_private {

serde/src/private/de.rs

@@ -518,7 +518,7 @@ mod content {
     impl<'de> TagOrContentVisitor<'de> {
         fn new(name: &'static str) -> Self {
             TagOrContentVisitor {
-                name: name,
+                name,
                 value: PhantomData,
             }
         }
@@ -815,7 +815,7 @@ mod content {
         pub fn new(name: &'static str, expecting: &'static str) -> Self {
             TaggedContentVisitor {
                 tag_name: name,
-                expecting: expecting,
+                expecting,
                 value: PhantomData,
             }
         }
@@ -859,7 +859,7 @@ mod content {
             };
             let rest = de::value::SeqAccessDeserializer::new(seq);
             Ok(TaggedContent {
-                tag: tag,
+                tag,
                 content: try!(Content::deserialize(rest)),
             })
         }
@@ -887,7 +887,7 @@ mod content {
             match tag {
                 None => Err(de::Error::missing_field(self.tag_name)),
                 Some(tag) => Ok(TaggedContent {
-                    tag: tag,
+                    tag,
                     content: Content::Map(vec),
                 }),
             }
@@ -982,9 +982,16 @@ mod content {
         where
             E: de::Error,
         {
-            if field == self.tag {
+            self.visit_bytes(field.as_bytes())
+        }
+
+        fn visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            if field == self.tag.as_bytes() {
                 Ok(TagContentOtherField::Tag)
-            } else if field == self.content {
+            } else if field == self.content.as_bytes() {
                 Ok(TagContentOtherField::Content)
             } else {
                 Ok(TagContentOtherField::Other)
@@ -1262,6 +1269,17 @@ mod content {
         {
             match self.content {
                 Content::Unit => visitor.visit_unit(),
+
+                // Allow deserializing newtype variant containing unit.
+                //
+                //     #[derive(Deserialize)]
+                //     #[serde(tag = "result")]
+                //     enum Response<T> {
+                //         Success(T),
+                //     }
+                //
+                // We want {"result":"Success"} to deserialize into Response<()>.
+                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -1446,7 +1464,7 @@ mod content {
         /// private API, don't use
         pub fn new(content: Content<'de>) -> Self {
             ContentDeserializer {
-                content: content,
+                content,
                 err: PhantomData,
             }
         }
@@ -1467,8 +1485,8 @@ mod content {
     {
         pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E> {
             EnumDeserializer {
-                variant: variant,
-                value: value,
+                variant,
+                value,
                 err: PhantomData,
             }
         }
@@ -1799,7 +1817,7 @@ mod content {
         V: Visitor<'de>,
         E: de::Error,
     {
-        let map = content.iter().map(|&(ref k, ref v)| {
+        let map = content.iter().map(|(k, v)| {
             (
                 ContentRefDeserializer::new(k),
                 ContentRefDeserializer::new(v),
@@ -2096,7 +2114,7 @@ mod content {
             let (variant, value) = match *self.content {
                 Content::Map(ref value) => {
                     let mut iter = value.iter();
-                    let &(ref variant, ref value) = match iter.next() {
+                    let (variant, value) = match iter.next() {
                         Some(v) => v,
                         None => {
                             return Err(de::Error::invalid_value(
@@ -2124,8 +2142,8 @@ mod content {
             };
 
             visitor.visit_enum(EnumRefDeserializer {
-                variant: variant,
-                value: value,
+                variant,
+                value,
                 err: PhantomData,
             })
         }
@@ -2169,12 +2187,20 @@ mod content {
         /// private API, don't use
         pub fn new(content: &'a Content<'de>) -> Self {
             ContentRefDeserializer {
-                content: content,
+                content,
                 err: PhantomData,
             }
         }
     }
 
+    impl<'a, 'de: 'a, E> Copy for ContentRefDeserializer<'a, 'de, E> {}
+
+    impl<'a, 'de: 'a, E> Clone for ContentRefDeserializer<'a, 'de, E> {
+        fn clone(&self) -> Self {
+            *self
+        }
+    }
+
     struct EnumRefDeserializer<'a, 'de: 'a, E>
     where
         E: de::Error,
@@ -2243,7 +2269,7 @@ mod content {
             V: de::Visitor<'de>,
         {
             match self.value {
-                Some(&Content::Seq(ref v)) => {
+                Some(Content::Seq(v)) => {
                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                 }
                 Some(other) => Err(de::Error::invalid_type(
@@ -2266,10 +2292,10 @@ mod content {
             V: de::Visitor<'de>,
         {
             match self.value {
-                Some(&Content::Map(ref v)) => {
+                Some(Content::Map(v)) => {
                     de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
                 }
-                Some(&Content::Seq(ref v)) => {
+                Some(Content::Seq(v)) => {
                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                 }
                 Some(other) => Err(de::Error::invalid_type(
@@ -2392,7 +2418,7 @@ mod content {
             T: de::DeserializeSeed<'de>,
         {
             match self.iter.next() {
-                Some(&(ref key, ref value)) => {
+                Some((key, value)) => {
                     self.value = Some(value);
                     seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
                 }
@@ -2470,8 +2496,8 @@ mod content {
         /// Not public API.
         pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
             InternallyTaggedUnitVisitor {
-                type_name: type_name,
-                variant_name: variant_name,
+                type_name,
+                variant_name,
             }
         }
     }
@@ -2515,8 +2541,8 @@ mod content {
         /// Not public API.
         pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
             UntaggedUnitVisitor {
-                type_name: type_name,
-                variant_name: variant_name,
+                type_name,
+                variant_name,
             }
         }
     }
@@ -2697,7 +2723,7 @@ where
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! forward_to_deserialize_other {
-    ($($func:ident ( $($arg:ty),* ))*) => {
+    ($($func:ident ($($arg:ty),*))*) => {
         $(
             fn $func<V>(self, $(_: $arg,)* _visitor: V) -> Result<V::Value, Self::Error>
             where
@@ -2720,11 +2746,7 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_map(FlatInternallyTaggedAccess {
-            iter: self.0.iter_mut(),
-            pending: None,
-            _marker: PhantomData,
-        })
+        self.deserialize_map(visitor)
     }
 
     fn deserialize_enum<V>(
@@ -2736,17 +2758,8 @@ where
     where
         V: Visitor<'de>,
     {
-        for item in self.0.iter_mut() {
-            // items in the vector are nulled out when used.  So we can only use
-            // an item if it's still filled in and if the field is one we care
-            // about.
-            let use_item = match *item {
-                None => false,
-                Some((ref c, _)) => c.as_str().map_or(false, |x| variants.contains(&x)),
-            };
-
-            if use_item {
-                let (key, value) = item.take().unwrap();
+        for entry in self.0 {
+            if let Some((key, value)) = flat_map_take_entry(entry, variants) {
                 return visitor.visit_enum(EnumDeserializer::new(key, Some(value)));
             }
         }
@@ -2761,7 +2774,11 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_map(FlatMapAccess::new(self.0.iter()))
+        visitor.visit_map(FlatMapAccess {
+            iter: self.0.iter(),
+            pending_content: None,
+            _marker: PhantomData,
+        })
     }
 
     fn deserialize_struct<V>(
@@ -2773,7 +2790,12 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_map(FlatStructAccess::new(self.0.iter_mut(), fields))
+        visitor.visit_map(FlatStructAccess {
+            iter: self.0.iter_mut(),
+            pending_content: None,
+            fields,
+            _marker: PhantomData,
+        })
     }
 
     fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
@@ -2827,25 +2849,12 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapAccess<'a, 'de: 'a, E> {
+struct FlatMapAccess<'a, 'de: 'a, E> {
     iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
     pending_content: Option<&'a Content<'de>>,
     _marker: PhantomData<E>,
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
-    fn new(
-        iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
-    ) -> FlatMapAccess<'a, 'de, E> {
-        FlatMapAccess {
-            iter: iter,
-            pending_content: None,
-            _marker: PhantomData,
-        }
-    }
-}
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
 where
@@ -2860,6 +2869,10 @@ where
         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 {
+                // Do not take(), instead borrow this entry. The internally tagged
+                // enum does its own buffering so we can't tell whether this entry
+                // is going to be consumed. Borrowing here leaves the entry
+                // available for later flattened fields.
                 self.pending_content = Some(content);
                 return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
             }
@@ -2879,28 +2892,13 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatStructAccess<'a, 'de: 'a, E> {
+struct FlatStructAccess<'a, 'de: 'a, E> {
     iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
     pending_content: Option<Content<'de>>,
     fields: &'static [&'static str],
     _marker: PhantomData<E>,
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> FlatStructAccess<'a, 'de, E> {
-    fn new(
-        iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-        fields: &'static [&'static str],
-    ) -> FlatStructAccess<'a, 'de, E> {
-        FlatStructAccess {
-            iter: iter,
-            pending_content: None,
-            fields: fields,
-            _marker: PhantomData,
-        }
-    }
-}
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, 'de, E> MapAccess<'de> for FlatStructAccess<'a, 'de, E>
 where
@@ -2912,17 +2910,8 @@ where
     where
         T: DeserializeSeed<'de>,
     {
-        while let Some(item) = self.iter.next() {
-            // items in the vector are nulled out when used.  So we can only use
-            // an item if it's still filled in and if the field is one we care
-            // about.  In case we do not know which fields we want, we take them all.
-            let use_item = match *item {
-                None => false,
-                Some((ref c, _)) => c.as_str().map_or(false, |key| self.fields.contains(&key)),
-            };
-
-            if use_item {
-                let (key, content) = item.take().unwrap();
+        for entry in self.iter.by_ref() {
+            if let Some((key, content)) = flat_map_take_entry(entry, self.fields) {
                 self.pending_content = Some(content);
                 return seed.deserialize(ContentDeserializer::new(key)).map(Some);
             }
@@ -2941,44 +2930,24 @@ where
     }
 }
 
+/// Claims one key-value pair from a FlatMapDeserializer's field buffer if the
+/// field name matches any of the recognized ones.
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatInternallyTaggedAccess<'a, 'de: 'a, E> {
-    iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-    pending: Option<&'a Content<'de>>,
-    _marker: PhantomData<E>,
-}
+fn flat_map_take_entry<'de>(
+    entry: &mut Option<(Content<'de>, Content<'de>)>,
+    recognized: &[&str],
+) -> Option<(Content<'de>, Content<'de>)> {
+    // Entries in the FlatMapDeserializer buffer are nulled out as they get
+    // claimed for deserialization. We only use an entry if it is still present
+    // and if the field is one recognized by the current data structure.
+    let is_recognized = match entry {
+        None => false,
+        Some((k, _v)) => k.as_str().map_or(false, |name| recognized.contains(&name)),
+    };
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> MapAccess<'de> for FlatInternallyTaggedAccess<'a, 'de, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        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
-                // is going to be consumed. Borrowing here leaves the entry
-                // available for later flattened fields.
-                self.pending = Some(content);
-                return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
-            }
-        }
-        Ok(None)
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.pending.take() {
-            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
-            None => panic!("value is missing"),
-        }
+    if is_recognized {
+        entry.take()
+    } else {
+        None
     }
 }

serde/src/private/ser.rs

@@ -27,10 +27,10 @@ where
     T: Serialize,
 {
     value.serialize(TaggedSerializer {
-        type_ident: type_ident,
-        variant_ident: variant_ident,
-        tag: tag,
-        variant_name: variant_name,
+        type_ident,
+        variant_ident,
+        tag,
+        variant_name,
         delegate: serializer,
     })
 }
@@ -51,7 +51,6 @@ enum Unsupported {
     String,
     ByteArray,
     Optional,
-    Unit,
     #[cfg(any(feature = "std", feature = "alloc"))]
     UnitStruct,
     Sequence,
@@ -70,7 +69,6 @@ impl Display for Unsupported {
             Unsupported::String => formatter.write_str("a string"),
             Unsupported::ByteArray => formatter.write_str("a byte array"),
             Unsupported::Optional => formatter.write_str("an optional"),
-            Unsupported::Unit => formatter.write_str("unit"),
             #[cfg(any(feature = "std", feature = "alloc"))]
             Unsupported::UnitStruct => formatter.write_str("unit struct"),
             Unsupported::Sequence => formatter.write_str("a sequence"),
@@ -184,7 +182,9 @@ where
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Unit))
+        let mut map = try!(self.delegate.serialize_map(Some(1)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        map.end()
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
@@ -350,8 +350,8 @@ mod content {
     impl<M> SerializeTupleVariantAsMapValue<M> {
         pub fn new(map: M, name: &'static str, len: usize) -> Self {
             SerializeTupleVariantAsMapValue {
-                map: map,
-                name: name,
+                map,
+                name,
                 fields: Vec::with_capacity(len),
             }
         }
@@ -390,8 +390,8 @@ mod content {
     impl<M> SerializeStructVariantAsMapValue<M> {
         pub fn new(map: M, name: &'static str, len: usize) -> Self {
             SerializeStructVariantAsMapValue {
-                map: map,
-                name: name,
+                map,
+                name,
                 fields: Vec::with_capacity(len),
             }
         }
@@ -525,7 +525,7 @@ mod content {
                 Content::Map(ref entries) => {
                     use ser::SerializeMap;
                     let mut map = try!(serializer.serialize_map(Some(entries.len())));
-                    for &(ref k, ref v) in entries {
+                    for (k, v) in entries {
                         try!(map.serialize_entry(k, v));
                     }
                     map.end()
@@ -711,7 +711,7 @@ mod content {
             len: usize,
         ) -> Result<Self::SerializeTupleStruct, E> {
             Ok(SerializeTupleStruct {
-                name: name,
+                name,
                 fields: Vec::with_capacity(len),
                 error: PhantomData,
             })
@@ -725,9 +725,9 @@ mod content {
             len: usize,
         ) -> Result<Self::SerializeTupleVariant, E> {
             Ok(SerializeTupleVariant {
-                name: name,
-                variant_index: variant_index,
-                variant: variant,
+                name,
+                variant_index,
+                variant,
                 fields: Vec::with_capacity(len),
                 error: PhantomData,
             })
@@ -747,7 +747,7 @@ mod content {
             len: usize,
         ) -> Result<Self::SerializeStruct, E> {
             Ok(SerializeStruct {
-                name: name,
+                name,
                 fields: Vec::with_capacity(len),
                 error: PhantomData,
             })
@@ -761,9 +761,9 @@ mod content {
             len: usize,
         ) -> Result<Self::SerializeStructVariant, E> {
             Ok(SerializeStructVariant {
-                name: name,
-                variant_index: variant_index,
-                variant: variant,
+                name,
+                variant_index,
+                variant,
                 fields: Vec::with_capacity(len),
                 error: PhantomData,
             })
@@ -1273,8 +1273,8 @@ where
 {
     fn new(map: &'a mut M, name: &'static str) -> FlatMapSerializeStructVariantAsMapValue<'a, M> {
         FlatMapSerializeStructVariantAsMapValue {
-            map: map,
-            name: name,
+            map,
+            name,
             fields: Vec::new(),
         }
     }

serde/src/ser/impls.rs

@@ -72,7 +72,7 @@ impl<'a> Serialize for fmt::Arguments<'a> {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", not(no_core_cstr)))]
 impl Serialize for CStr {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -83,7 +83,7 @@ impl Serialize for CStr {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 impl Serialize for CString {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -182,9 +182,27 @@ where
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
 macro_rules! seq_impl {
-    ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => {
+    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
+        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
+        where
+            T: Serialize,
+        {
+            #[inline]
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                serializer.collect_seq(self)
+            }
+        }
+    }
+}
+
+#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
+macro_rules! seq_impl {
+    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
         impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
         where
             T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
@@ -347,9 +365,28 @@ tuple_impls! {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
 macro_rules! map_impl {
-    ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => {
+    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
+        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
+        where
+            K: Serialize,
+            V: Serialize,
+        {
+            #[inline]
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                serializer.collect_map(self)
+            }
+        }
+    }
+}
+
+#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
+macro_rules! map_impl {
+    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
         impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
         where
             K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
@@ -465,7 +502,7 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! nonzero_integers {
-    ( $( $T: ident, )+ ) => {
+    ($($T:ident,)+) => {
         $(
             #[cfg(not(no_num_nonzero))]
             impl Serialize for num::$T {
@@ -522,7 +559,7 @@ where
     }
 }
 
-impl<T> Serialize for RefCell<T>
+impl<T: ?Sized> Serialize for RefCell<T>
 where
     T: Serialize,
 {
@@ -538,7 +575,7 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<T> Serialize for Mutex<T>
+impl<T: ?Sized> Serialize for Mutex<T>
 where
     T: Serialize,
 {
@@ -554,7 +591,7 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<T> Serialize for RwLock<T>
+impl<T: ?Sized> Serialize for RwLock<T>
 where
     T: Serialize,
 {
@@ -614,9 +651,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()));
@@ -675,7 +713,7 @@ impl Serialize for net::IpAddr {
 }
 
 #[cfg(feature = "std")]
-const DEC_DIGITS_LUT: &'static [u8] = b"\
+const DEC_DIGITS_LUT: &[u8] = b"\
       0001020304050607080910111213141516171819\
       2021222324252627282930313233343536373839\
       4041424344454647484950515253545556575859\
@@ -735,8 +773,9 @@ impl Serialize for net::Ipv4Addr {
                 // Skip over delimiters that we initialized buf with
                 written += format_u8(*oct, &mut buf[written + 1..]) + 1;
             }
-            // We've only written ASCII bytes to the buffer, so it is valid UTF-8
-            serializer.serialize_str(unsafe { str::from_utf8_unchecked(&buf[..written]) })
+            // Safety: We've only written ASCII bytes to the buffer, so it is valid UTF-8
+            let buf = unsafe { str::from_utf8_unchecked(&buf[..written]) };
+            serializer.serialize_str(buf)
         } else {
             self.octets().serialize(serializer)
         }
@@ -908,15 +947,16 @@ where
 
 #[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
-    ($($ty:ident)*) => {
+    ($($ty:ident $size:expr)*) => {
         $(
+            #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
             impl Serialize for $ty {
                 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                 where
                     S: Serializer,
                 {
                     // Matches the atomic ordering used in libcore for the Debug impl
-                    self.load(Ordering::SeqCst).serialize(serializer)
+                    self.load(Ordering::Relaxed).serialize(serializer)
                 }
             }
         )*
@@ -925,12 +965,19 @@ macro_rules! atomic_impl {
 
 #[cfg(all(feature = "std", not(no_std_atomic)))]
 atomic_impl! {
-    AtomicBool
-    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
-    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+    AtomicBool "8"
+    AtomicI8 "8"
+    AtomicI16 "16"
+    AtomicI32 "32"
+    AtomicIsize "ptr"
+    AtomicU8 "8"
+    AtomicU16 "16"
+    AtomicU32 "32"
+    AtomicUsize "ptr"
 }
 
 #[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
-    AtomicI64 AtomicU64
+    AtomicI64 "64"
+    AtomicU64 "64"
 }

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/bincode-org/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
@@ -115,10 +115,13 @@ mod impossible;
 
 pub use self::impossible::Impossible;
 
+#[cfg(all(feature = "unstable", not(feature = "std")))]
+#[doc(inline)]
+pub use core::error::Error as StdError;
 #[cfg(feature = "std")]
 #[doc(no_inline)]
 pub use std::error::Error as StdError;
-#[cfg(not(feature = "std"))]
+#[cfg(not(any(feature = "std", feature = "unstable")))]
 #[doc(no_inline)]
 pub use std_error::Error as StdError;
 
@@ -191,8 +194,8 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// by Serde.
 ///
 /// Serde provides `Serialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][ser]. All of these can
-/// be serialized using Serde out of the box.
+/// standard library types. The complete list is [here][crate::ser]. All of
+/// these can be serialized using Serde out of the box.
 ///
 /// Additionally, Serde provides a procedural macro called [`serde_derive`] to
 /// automatically generate `Serialize` implementations for structs and enums in
@@ -212,7 +215,6 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 /// [`serde_derive`]: https://crates.io/crates/serde_derive
 /// [derive section of the manual]: https://serde.rs/derive.html
-/// [ser]: https://docs.serde.rs/serde/ser/index.html
 pub trait Serialize {
     /// Serialize this value into the given Serde serializer.
     ///
@@ -314,7 +316,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
@@ -1423,7 +1425,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

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

serde_derive/Cargo.toml

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

serde_derive/build.rs

@@ -1,36 +0,0 @@
-use std::env;
-use std::process::Command;
-use std::str;
-
-// 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,
-    };
-
-    // 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=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");
-    }
-}
-
-fn rustc_minor_version() -> Option<u32> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    pieces.next()?.parse().ok()
-}

serde_derive/src/bound.rs

@@ -200,10 +200,16 @@ pub fn with_bound(
                     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::AssocType(arg) => self.visit_type(&arg.ty),
                             syn::GenericArgument::Lifetime(_)
-                            | syn::GenericArgument::Constraint(_)
-                            | syn::GenericArgument::Const(_) => {}
+                            | syn::GenericArgument::Const(_)
+                            | syn::GenericArgument::AssocConst(_)
+                            | syn::GenericArgument::Constraint(_) => {}
+                            #[cfg_attr(
+                                all(test, exhaustive),
+                                deny(non_exhaustive_omitted_patterns)
+                            )]
+                            _ => {}
                         }
                     }
                 }
@@ -226,7 +232,9 @@ pub fn with_bound(
         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(_) => {}
+                syn::TypeParamBound::Lifetime(_) | syn::TypeParamBound::Verbatim(_) => {}
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                _ => {}
             }
         }
 
@@ -251,7 +259,7 @@ pub fn with_bound(
     };
     match &cont.data {
         Data::Enum(variants) => {
-            for variant in variants.iter() {
+            for variant in variants {
                 let relevant_fields = variant
                     .fields
                     .iter()
@@ -334,7 +342,7 @@ pub fn with_self_bound(
 
 pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
     let bound = syn::Lifetime::new(lifetime, Span::call_site());
-    let def = syn::LifetimeDef {
+    let def = syn::LifetimeParam {
         attrs: Vec::new(),
         lifetime: bound.clone(),
         colon_token: None,

serde_derive/src/de.rs

@@ -10,13 +10,12 @@ use fragment::{Expr, Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
 use pretend;
+use this;
 
 use std::collections::BTreeSet;
 use std::ptr;
 
-pub fn expand_derive_deserialize(
-    input: &mut syn::DeriveInput,
-) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<TokenStream> {
     replace_receiver(input);
 
     let ctxt = Ctxt::new();
@@ -68,8 +67,6 @@ pub fn expand_derive_deserialize(
 
     Ok(dummy::wrap_in_const(
         cont.attrs.custom_serde_path(),
-        "DESERIALIZE",
-        ident,
         impl_block,
     ))
 }
@@ -111,9 +108,13 @@ struct Parameters {
     local: syn::Ident,
 
     /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
+    /// types (does not include generic parameters) or `some::remote::Path` for
+    /// remote types.
+    this_type: syn::Path,
+
+    /// Same as `this_type` but using `::<T>` for generic parameters for use in
+    /// expression position.
+    this_value: syn::Path,
 
     /// Generics including any explicit and inferred bounds for the impl.
     generics: syn::Generics,
@@ -133,10 +134,8 @@ struct Parameters {
 impl Parameters {
     fn new(cont: &Container) -> Self {
         let local = cont.ident.clone();
-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
+        let this_type = this::this_type(cont);
+        let this_value = this::this_value(cont);
         let borrowed = borrowed_lifetimes(cont);
         let generics = build_generics(cont, &borrowed);
         let has_getter = cont.data.has_getter();
@@ -144,7 +143,8 @@ impl Parameters {
 
         Parameters {
             local,
-            this,
+            this_type,
+            this_value,
             generics,
             borrowed,
             has_getter,
@@ -155,7 +155,7 @@ impl Parameters {
     /// Type name to use in error messages and `&'static str` arguments to
     /// various Deserializer methods.
     fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
+        self.this_type.segments.last().unwrap().ident.to_string()
     }
 }
 
@@ -240,9 +240,9 @@ impl BorrowedLifetimes {
         }
     }
 
-    fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
+    fn de_lifetime_param(&self) -> Option<syn::LifetimeParam> {
         match self {
-            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeDef {
+            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeParam {
                 attrs: Vec::new(),
                 lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
@@ -358,7 +358,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
         Data::Enum(_) => unreachable!(),
     };
 
-    let this = &params.this;
+    let this_value = &params.this_value;
     let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
 
     let path = match transparent_field.attrs.deserialize_with() {
@@ -386,7 +386,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
     quote_block! {
         _serde::__private::Result::map(
             #path(__deserializer),
-            |__transparent| #this { #(#assign),* })
+            |__transparent| #this_value { #(#assign),* })
     }
 }
 
@@ -407,17 +407,19 @@ fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
 }
 
 fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let type_name = cattrs.name().deserialize_name();
 
     let expecting = format!("unit struct {}", params.type_name());
     let expecting = cattrs.expecting().unwrap_or(&expecting);
 
     quote_block! {
+        #[doc(hidden)]
         struct __Visitor;
 
         impl<'de> _serde::de::Visitor<'de> for __Visitor {
-            type Value = #this;
+            type Value = #this_type;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -428,7 +430,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::Ok(#this)
+                _serde::__private::Ok(#this_value)
             }
         }
 
@@ -443,13 +445,19 @@ fn deserialize_tuple(
     cattrs: &attr::Container,
     deserializer: Option<TokenStream>,
 ) -> Fragment {
-    let this = &params.this;
+    assert!(!cattrs.has_flatten());
+
+    let field_count = fields
+        .iter()
+        .filter(|field| !field.attrs.skip_deserializing())
+        .count();
+
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
 
-    assert!(!cattrs.has_flatten());
-
     // If there are getters (implying private fields), construct the local type
     // and use an `Into` conversion to get the remote type. If there are no
     // getters then construct the target type directly.
@@ -457,7 +465,7 @@ fn deserialize_tuple(
         let local = &params.local;
         quote!(#local)
     } else {
-        quote!(#this)
+        quote!(#this_value)
     };
 
     let is_enum = variant_ident.is_some();
@@ -485,37 +493,37 @@ fn deserialize_tuple(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData,
         }
     };
     let dispatch = if let Some(deserializer) = deserializer {
-        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
+        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #field_count, #visitor_expr))
     } else if is_enum {
-        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
+        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #field_count, #visitor_expr))
     } else if nfields == 1 {
         let type_name = cattrs.name().deserialize_name();
         quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
     } else {
         let type_name = cattrs.name().deserialize_name();
-        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
+        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #field_count, #visitor_expr))
     };
 
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let visitor_var = if all_skipped {
+    let visitor_var = if field_count == 0 {
         quote!(_)
     } else {
         quote!(mut __seq)
     };
 
     quote_block! {
+        #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -544,13 +552,18 @@ fn deserialize_tuple_in_place(
     cattrs: &attr::Container,
     deserializer: Option<TokenStream>,
 ) -> Fragment {
-    let this = &params.this;
+    assert!(!cattrs.has_flatten());
+
+    let field_count = fields
+        .iter()
+        .filter(|field| !field.attrs.skip_deserializing())
+        .count();
+
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
 
-    assert!(!cattrs.has_flatten());
-
     let is_enum = variant_ident.is_some();
     let expecting = match variant_ident {
         Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
@@ -576,19 +589,18 @@ fn deserialize_tuple_in_place(
     };
 
     let dispatch = if let Some(deserializer) = deserializer {
-        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
+        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #field_count, #visitor_expr))
     } else if is_enum {
-        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
+        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #field_count, #visitor_expr))
     } else if nfields == 1 {
         let type_name = cattrs.name().deserialize_name();
         quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
     } else {
         let type_name = cattrs.name().deserialize_name();
-        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
+        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #field_count, #visitor_expr))
     };
 
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let visitor_var = if all_skipped {
+    let visitor_var = if field_count == 0 {
         quote!(_)
     } else {
         quote!(mut __seq)
@@ -599,8 +611,9 @@ fn deserialize_tuple_in_place(
     let place_life = place_lifetime();
 
     quote_block! {
+        #[doc(hidden)]
         struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this #ty_generics,
+            place: &#place_life mut #this_type #ty_generics,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
@@ -705,9 +718,10 @@ fn deserialize_seq(
     };
 
     if params.has_getter {
-        let this = &params.this;
+        let this_type = &params.this_type;
+        let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -801,14 +815,14 @@ fn deserialize_seq_in_place(
         }
     });
 
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (_, ty_generics, _) = params.generics.split_for_impl();
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics  = _serde::__private::Default::default();
+            let __default: #this_type #ty_generics = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
-            let __default: #this #ty_generics  = #path();
+            let __default: #this_type #ty_generics = #path();
         )),
         attr::Default::None => {
             // We don't need the default value, to prevent an unused variable warning
@@ -849,9 +863,10 @@ fn deserialize_newtype_struct(
 
     let mut result = quote!(#type_path(__field0));
     if params.has_getter {
-        let this = &params.this;
+        let this_type = &params.this_type;
+        let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -901,7 +916,8 @@ fn deserialize_struct(
 ) -> Fragment {
     let is_enum = variant_ident.is_some();
 
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -913,7 +929,7 @@ fn deserialize_struct(
         let local = &params.local;
         quote!(#local)
     } else {
-        quote!(#this)
+        quote!(#this_value)
     };
 
     let type_path = match variant_ident {
@@ -941,10 +957,11 @@ fn deserialize_struct(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData,
         }
     };
+    let need_seed = deserializer.is_none();
     let dispatch = if let Some(deserializer) = deserializer {
         quote! {
             _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
@@ -990,14 +1007,14 @@ fn deserialize_struct(
         _ => None,
     };
 
-    let visitor_seed = if is_enum && cattrs.has_flatten() {
+    let visitor_seed = if need_seed && is_enum && cattrs.has_flatten() {
         Some(quote! {
             impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
-                type Value = #this #ty_generics;
+                type Value = #this_type #ty_generics;
 
                 fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
                 where
-                    __D: _serde::Deserializer<'de>,
+                    __D: _serde::Deserializer<#delife>,
                 {
                     _serde::Deserializer::deserialize_map(__deserializer, self)
                 }
@@ -1010,13 +1027,14 @@ fn deserialize_struct(
     quote_block! {
         #field_visitor
 
+        #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1057,7 +1075,7 @@ fn deserialize_struct_in_place(
         return None;
     }
 
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -1122,8 +1140,9 @@ fn deserialize_struct_in_place(
     Some(quote_block! {
         #field_visitor
 
+        #[doc(hidden)]
         struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this #ty_generics,
+            place: &#place_life mut #this_type #ty_generics,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
@@ -1155,6 +1174,22 @@ fn deserialize_enum(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
+) -> Fragment {
+    // The variants have already been checked (in ast.rs) that all untagged variants appear at the end
+    match variants.iter().position(|var| var.attrs.untagged()) {
+        Some(variant_idx) => {
+            let (tagged, untagged) = variants.split_at(variant_idx);
+            let tagged_frag = Expr(deserialize_homogeneous_enum(params, tagged, cattrs));
+            deserialize_untagged_enum_after(params, untagged, cattrs, Some(tagged_frag))
+        }
+        None => deserialize_homogeneous_enum(params, variants, cattrs),
+    }
+}
+
+fn deserialize_homogeneous_enum(
+    params: &Parameters,
+    variants: &[Variant],
+    cattrs: &attr::Container,
 ) -> Fragment {
     match cattrs.tag() {
         attr::TagType::External => deserialize_externally_tagged_enum(params, variants, cattrs),
@@ -1193,6 +1228,7 @@ fn prepare_enum_variant_enum(
     let variants_stmt = {
         let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
         quote! {
+            #[doc(hidden)]
             const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
         }
     };
@@ -1212,7 +1248,7 @@ fn deserialize_externally_tagged_enum(
     variants: &[Variant],
     cattrs: &attr::Container,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -1247,7 +1283,7 @@ fn deserialize_externally_tagged_enum(
         // This is an empty enum like `enum Impossible {}` or an enum in which
         // all variants have `#[serde(skip_deserializing)]`.
         quote! {
-            // FIXME: Once we drop support for Rust 1.15:
+            // FIXME: Once feature(exhaustive_patterns) is stable:
             // let _serde::__private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
             // _serde::__private::Err(__err)
             _serde::__private::Result::map(
@@ -1265,13 +1301,14 @@ fn deserialize_externally_tagged_enum(
     quote_block! {
         #variant_visitor
 
+        #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1292,7 +1329,7 @@ fn deserialize_externally_tagged_enum(
             #type_name,
             VARIANTS,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this #ty_generics>,
+                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
                 lifetime: _serde::__private::PhantomData,
             },
         )
@@ -1354,7 +1391,8 @@ fn deserialize_adjacently_tagged_enum(
     tag: &str,
     content: &str,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
+    let this_value = &params.this_value;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
@@ -1415,13 +1453,13 @@ fn deserialize_adjacently_tagged_enum(
 
             let arm = match variant.style {
                 Style::Unit => quote! {
-                    _serde::__private::Ok(#this::#variant_ident)
+                    _serde::__private::Ok(#this_value::#variant_ident)
                 },
                 Style::Newtype if variant.attrs.deserialize_with().is_none() => {
                     let span = variant.original.span();
                     let func = quote_spanned!(span=> _serde::__private::de::missing_field);
                     quote! {
-                        #func(#content).map(#this::#variant_ident)
+                        #func(#content).map(#this_value::#variant_ident)
                     }
                 }
                 _ => {
@@ -1511,14 +1549,15 @@ fn deserialize_adjacently_tagged_enum(
 
         #variants_stmt
 
+        #[doc(hidden)]
         struct __Seed #de_impl_generics #where_clause {
             field: __Field,
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
             where
@@ -1530,13 +1569,14 @@ fn deserialize_adjacently_tagged_enum(
             }
         }
 
+        #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                 _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1632,13 +1672,14 @@ fn deserialize_adjacently_tagged_enum(
             }
         }
 
+        #[doc(hidden)]
         const FIELDS: &'static [&'static str] = &[#tag, #content];
         _serde::Deserializer::deserialize_struct(
             __deserializer,
             #type_name,
             FIELDS,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this #ty_generics>,
+                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
                 lifetime: _serde::__private::PhantomData,
             },
         )
@@ -1649,6 +1690,16 @@ fn deserialize_untagged_enum(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
+) -> Fragment {
+    let first_attempt = None;
+    deserialize_untagged_enum_after(params, variants, cattrs, first_attempt)
+}
+
+fn deserialize_untagged_enum_after(
+    params: &Parameters,
+    variants: &[Variant],
+    cattrs: &attr::Container,
+    first_attempt: Option<Expr>,
 ) -> Fragment {
     let attempts = variants
         .iter()
@@ -1658,12 +1709,10 @@ fn deserialize_untagged_enum(
                 params,
                 variant,
                 cattrs,
-                quote!(
-                    _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content)
-                ),
+                quote!(__deserializer),
             ))
         });
-
+    let attempts = first_attempt.into_iter().chain(attempts);
     // TODO this message could be better by saving the errors from the failed
     // attempts. The heuristic used by TOML was to count the number of fields
     // processed before an error, and use the error that happened after the
@@ -1678,6 +1727,7 @@ fn deserialize_untagged_enum(
 
     quote_block! {
         let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
+        let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
 
         #(
             if let _serde::__private::Ok(__ok) = #attempts {
@@ -1707,10 +1757,10 @@ fn deserialize_externally_tagged_variant(
 
     match variant.style {
         Style::Unit => {
-            let this = &params.this;
+            let this_value = &params.this_value;
             quote_block! {
                 try!(_serde::de::VariantAccess::unit_variant(__variant));
-                _serde::__private::Ok(#this::#variant_ident)
+                _serde::__private::Ok(#this_value::#variant_ident)
             }
         }
         Style::Newtype => deserialize_externally_tagged_newtype_variant(
@@ -1749,7 +1799,7 @@ fn deserialize_internally_tagged_variant(
 
     match effective_style(variant) {
         Style::Unit => {
-            let this = &params.this;
+            let this_value = &params.this_value;
             let type_name = params.type_name();
             let variant_name = variant.ident.to_string();
             let default = variant.fields.get(0).map(|field| {
@@ -1758,7 +1808,7 @@ fn deserialize_internally_tagged_variant(
             });
             quote_block! {
                 try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
-                _serde::__private::Ok(#this::#variant_ident #default)
+                _serde::__private::Ok(#this_value::#variant_ident #default)
             }
         }
         Style::Newtype => deserialize_untagged_newtype_variant(
@@ -1796,7 +1846,7 @@ fn deserialize_untagged_variant(
 
     match effective_style(variant) {
         Style::Unit => {
-            let this = &params.this;
+            let this_value = &params.this_value;
             let type_name = params.type_name();
             let variant_name = variant.ident.to_string();
             let default = variant.fields.get(0).map(|field| {
@@ -1808,7 +1858,7 @@ fn deserialize_untagged_variant(
                     #deserializer,
                     _serde::__private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
                 ) {
-                    _serde::__private::Ok(()) => _serde::__private::Ok(#this::#variant_ident #default),
+                    _serde::__private::Ok(()) => _serde::__private::Ok(#this_value::#variant_ident #default),
                     _serde::__private::Err(__err) => _serde::__private::Err(__err),
                 }
             }
@@ -1843,14 +1893,13 @@ fn deserialize_externally_tagged_newtype_variant(
     field: &Field,
     cattrs: &attr::Container,
 ) -> Fragment {
-    let this = &params.this;
+    let this_value = &params.this_value;
 
     if field.attrs.skip_deserializing() {
-        let this = &params.this;
         let default = Expr(expr_is_missing(field, cattrs));
         return quote_block! {
             try!(_serde::de::VariantAccess::unit_variant(__variant));
-            _serde::__private::Ok(#this::#variant_ident(#default))
+            _serde::__private::Ok(#this_value::#variant_ident(#default))
         };
     }
 
@@ -1861,7 +1910,7 @@ fn deserialize_externally_tagged_newtype_variant(
             let func =
                 quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
             quote_expr! {
-                _serde::__private::Result::map(#func(__variant), #this::#variant_ident)
+                _serde::__private::Result::map(#func(__variant), #this_value::#variant_ident)
             }
         }
         Some(path) => {
@@ -1870,7 +1919,7 @@ fn deserialize_externally_tagged_newtype_variant(
                 #wrapper
                 _serde::__private::Result::map(
                     _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
-                    |__wrapper| #this::#variant_ident(__wrapper.value))
+                    |__wrapper| #this_value::#variant_ident(__wrapper.value))
             }
         }
     }
@@ -1882,20 +1931,20 @@ fn deserialize_untagged_newtype_variant(
     field: &Field,
     deserializer: &TokenStream,
 ) -> Fragment {
-    let this = &params.this;
+    let this_value = &params.this_value;
     let field_ty = field.ty;
     match field.attrs.deserialize_with() {
         None => {
             let span = field.original.span();
             let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote_expr! {
-                _serde::__private::Result::map(#func(#deserializer), #this::#variant_ident)
+                _serde::__private::Result::map(#func(#deserializer), #this_value::#variant_ident)
             }
         }
         Some(path) => {
             quote_block! {
                 let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
-                _serde::__private::Result::map(__value, #this::#variant_ident)
+                _serde::__private::Result::map(__value, #this_value::#variant_ident)
             }
         }
     }
@@ -1907,7 +1956,7 @@ fn deserialize_generated_identifier(
     is_variant: bool,
     other_idx: Option<usize>,
 ) -> Fragment {
-    let this = quote!(__Field);
+    let this_value = quote!(__Field);
     let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
 
     let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
@@ -1927,7 +1976,7 @@ fn deserialize_generated_identifier(
     };
 
     let visitor_impl = Stmts(deserialize_identifier(
-        &this,
+        &this_value,
         fields,
         is_variant,
         fallthrough,
@@ -1944,11 +1993,13 @@ fn deserialize_generated_identifier(
 
     quote_block! {
         #[allow(non_camel_case_types)]
+        #[doc(hidden)]
         enum __Field #lifetime {
             #(#field_idents,)*
             #ignore_variant
         }
 
+        #[doc(hidden)]
         struct __FieldVisitor;
 
         impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
@@ -1982,8 +2033,8 @@ fn deserialize_custom_identifier(
         attr::Identifier::No => unreachable!(),
     };
 
-    let this = &params.this;
-    let this = quote!(#this);
+    let this_type = params.this_type.to_token_stream();
+    let this_value = params.this_value.to_token_stream();
 
     let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
         let last_ident = &last.ident;
@@ -1992,7 +2043,7 @@ fn deserialize_custom_identifier(
             // last variant (checked in `check_identifier`), so all preceding
             // are ordinary variants.
             let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident));
+            let fallthrough = quote!(_serde::__private::Ok(#this_value::#last_ident));
             (ordinary, Some(fallthrough), None)
         } else if let Style::Newtype = last.style {
             let ordinary = &variants[..variants.len() - 1];
@@ -2002,7 +2053,7 @@ fn deserialize_custom_identifier(
                         _serde::Deserialize::deserialize(
                             _serde::__private::de::IdentifierDeserializer::from(#value)
                         ),
-                        #this::#last_ident)
+                        #this_value::#last_ident)
                 }
             };
             (
@@ -2036,11 +2087,13 @@ fn deserialize_custom_identifier(
         None
     } else if is_variant {
         let variants = quote! {
+            #[doc(hidden)]
             const VARIANTS: &'static [&'static str] = &[ #(#names),* ];
         };
         Some(variants)
     } else {
         let fields = quote! {
+            #[doc(hidden)]
             const FIELDS: &'static [&'static str] = &[ #(#names),* ];
         };
         Some(fields)
@@ -2050,7 +2103,7 @@ fn deserialize_custom_identifier(
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
     let visitor_impl = Stmts(deserialize_identifier(
-        &this,
+        &this_value,
         &names_idents,
         is_variant,
         fallthrough,
@@ -2062,19 +2115,20 @@ fn deserialize_custom_identifier(
     quote_block! {
         #names_const
 
+        #[doc(hidden)]
         struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
+            type Value = #this_type #ty_generics;
 
             #visitor_impl
         }
 
         let __visitor = __FieldVisitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData,
         };
         _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
@@ -2082,7 +2136,7 @@ fn deserialize_custom_identifier(
 }
 
 fn deserialize_identifier(
-    this: &TokenStream,
+    this_value: &TokenStream,
     fields: &[(String, Ident, Vec<String>)],
     is_variant: bool,
     fallthrough: Option<TokenStream>,
@@ -2103,11 +2157,11 @@ fn deserialize_identifier(
 
     let constructors: &Vec<_> = &flat_fields
         .iter()
-        .map(|(_, ident)| quote!(#this::#ident))
+        .map(|(_, ident)| quote!(#this_value::#ident))
         .collect();
     let main_constructors: &Vec<_> = &fields
         .iter()
-        .map(|(_, ident, _)| quote!(#this::#ident))
+        .map(|(_, ident, _)| quote!(#this_value::#ident))
         .collect();
 
     let expecting = expecting.unwrap_or(if is_variant {
@@ -2391,8 +2445,12 @@ fn deserialize_struct_as_struct_visitor(
         .collect();
 
     let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
+        let field_names = field_names_idents
+            .iter()
+            .flat_map(|(_, _, aliases)| aliases);
+
         quote_block! {
+            #[doc(hidden)]
             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
         }
     };
@@ -2526,7 +2584,7 @@ fn deserialize_map(
     let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
-            // FIXME: Once we drop support for Rust 1.15:
+            // FIXME: Once feature(exhaustive_patterns) is stable:
             // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
             _serde::__private::Option::map(
                 try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
@@ -2621,9 +2679,10 @@ fn deserialize_map(
 
     let mut result = quote!(#struct_path { #(#result),* });
     if params.has_getter {
-        let this = &params.this;
+        let this_type = &params.this_type;
+        let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -2670,6 +2729,7 @@ fn deserialize_struct_as_struct_in_place_visitor(
     let fields_stmt = {
         let field_names = field_names_idents.iter().map(|(name, _, _)| name);
         quote_block! {
+            #[doc(hidden)]
             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
         }
     };
@@ -2758,7 +2818,7 @@ fn deserialize_map_in_place(
 
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
-            // FIXME: Once we drop support for Rust 1.15:
+            // FIXME: Once feature(exhaustive_patterns) is stable:
             // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
             _serde::__private::Option::map(
                 try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
@@ -2803,15 +2863,15 @@ fn deserialize_map_in_place(
             }
         });
 
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (_, _, ty_generics, _) = split_with_de_lifetime(params);
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics = _serde::__private::Default::default();
+            let __default: #this_type #ty_generics = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
-            let __default: #this #ty_generics = #path();
+            let __default: #this_type #ty_generics = #path();
         )),
         attr::Default::None => {
             // We don't need the default value, to prevent an unused variable warning
@@ -2844,15 +2904,16 @@ fn wrap_deserialize_with(
     value_ty: &TokenStream,
     deserialize_with: &syn::ExprPath,
 ) -> (TokenStream, TokenStream) {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
 
     let wrapper = quote! {
+        #[doc(hidden)]
         struct __DeserializeWith #de_impl_generics #where_clause {
             value: #value_ty,
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
             lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
@@ -2903,7 +2964,7 @@ fn unwrap_to_variant_closure(
     variant: &Variant,
     with_wrapper: bool,
 ) -> TokenStream {
-    let this = &params.this;
+    let this_value = &params.this_value;
     let variant_ident = &variant.ident;
 
     let (arg, wrapper) = if with_wrapper {
@@ -2924,23 +2985,23 @@ fn unwrap_to_variant_closure(
         Style::Struct if variant.fields.len() == 1 => {
             let member = &variant.fields[0].member;
             quote! {
-                |#arg| #this::#variant_ident { #member: #wrapper }
+                |#arg| #this_value::#variant_ident { #member: #wrapper }
             }
         }
         Style::Struct => {
             let members = variant.fields.iter().map(|field| &field.member);
             quote! {
-                |#arg| #this::#variant_ident { #(#members: #wrapper.#field_access),* }
+                |#arg| #this_value::#variant_ident { #(#members: #wrapper.#field_access),* }
             }
         }
         Style::Tuple => quote! {
-            |#arg| #this::#variant_ident(#(#wrapper.#field_access),*)
+            |#arg| #this_value::#variant_ident(#(#wrapper.#field_access),*)
         },
         Style::Newtype => quote! {
-            |#arg| #this::#variant_ident(#wrapper)
+            |#arg| #this_value::#variant_ident(#wrapper)
         },
         Style::Unit => quote! {
-            |#arg| #this::#variant_ident
+            |#arg| #this_value::#variant_ident
         },
     }
 }
@@ -2997,7 +3058,7 @@ struct InPlaceImplGenerics<'a>(&'a Parameters);
 impl<'a> ToTokens for DeImplGenerics<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut generics = self.0.generics.clone();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
+        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_param() {
             generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
                 .into_iter()
                 .chain(generics.params)
@@ -3032,7 +3093,7 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
             .into_iter()
             .chain(generics.params)
             .collect();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
+        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_param() {
             generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
                 .into_iter()
                 .chain(generics.params)
@@ -3054,23 +3115,31 @@ struct DeTypeGenerics<'a>(&'a Parameters);
 #[cfg(feature = "deserialize_in_place")]
 struct InPlaceTypeGenerics<'a>(&'a Parameters);
 
+fn de_type_generics_to_tokens(
+    mut generics: syn::Generics,
+    borrowed: &BorrowedLifetimes,
+    tokens: &mut TokenStream,
+) {
+    if borrowed.de_lifetime_param().is_some() {
+        let def = syn::LifetimeParam {
+            attrs: Vec::new(),
+            lifetime: syn::Lifetime::new("'de", Span::call_site()),
+            colon_token: None,
+            bounds: Punctuated::new(),
+        };
+        // Prepend 'de lifetime to list of generics
+        generics.params = Some(syn::GenericParam::Lifetime(def))
+            .into_iter()
+            .chain(generics.params)
+            .collect();
+    }
+    let (_, ty_generics, _) = generics.split_for_impl();
+    ty_generics.to_tokens(tokens);
+}
+
 impl<'a> ToTokens for DeTypeGenerics<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut generics = self.0.generics.clone();
-        if self.0.borrowed.de_lifetime_def().is_some() {
-            let def = syn::LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new("'de", Span::call_site()),
-                colon_token: None,
-                bounds: Punctuated::new(),
-            };
-            generics.params = Some(syn::GenericParam::Lifetime(def))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (_, ty_generics, _) = generics.split_for_impl();
-        ty_generics.to_tokens(tokens);
+        de_type_generics_to_tokens(self.0.generics.clone(), &self.0.borrowed, tokens);
     }
 }
 
@@ -3083,20 +3152,7 @@ impl<'a> ToTokens for InPlaceTypeGenerics<'a> {
             .chain(generics.params)
             .collect();
 
-        if self.0.borrowed.de_lifetime_def().is_some() {
-            let def = syn::LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new("'de", Span::call_site()),
-                colon_token: None,
-                bounds: Punctuated::new(),
-            };
-            generics.params = Some(syn::GenericParam::Lifetime(def))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (_, ty_generics, _) = generics.split_for_impl();
-        ty_generics.to_tokens(tokens);
+        de_type_generics_to_tokens(generics, &self.0.borrowed, tokens);
     }
 }
 
@@ -3108,8 +3164,8 @@ impl<'a> DeTypeGenerics<'a> {
 }
 
 #[cfg(feature = "deserialize_in_place")]
-fn place_lifetime() -> syn::LifetimeDef {
-    syn::LifetimeDef {
+fn place_lifetime() -> syn::LifetimeParam {
+    syn::LifetimeParam {
         attrs: Vec::new(),
         lifetime: syn::Lifetime::new("'place", Span::call_site()),
         colon_token: None,

serde_derive/src/dummy.rs

@@ -1,23 +1,11 @@
-use proc_macro2::{Ident, TokenStream};
-use quote::format_ident;
+use proc_macro2::TokenStream;
 
 use syn;
 use try;
 
-pub fn wrap_in_const(
-    serde_path: Option<&syn::Path>,
-    trait_: &str,
-    ty: &Ident,
-    code: TokenStream,
-) -> TokenStream {
+pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream {
     let try_replacement = try::replacement();
 
-    let dummy_const = if cfg!(no_underscore_consts) {
-        format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
-    } else {
-        format_ident!("_")
-    };
-
     let use_serde = match serde_path {
         Some(path) => quote! {
             use #path as _serde;
@@ -31,18 +19,10 @@ pub fn wrap_in_const(
     quote! {
         #[doc(hidden)]
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const #dummy_const: () = {
+        const _: () = {
             #use_serde
             #try_replacement
             #code
         };
     }
 }
-
-#[allow(deprecated)]
-fn unraw(ident: &Ident) -> String {
-    // str::trim_start_matches was added in 1.30, trim_left_matches deprecated
-    // in 1.33. We currently support rustc back to 1.15 so we need to continue
-    // to use the deprecated one.
-    ident.to_string().trim_left_matches("r#").to_owned()
-}

serde_derive/src/internals/ast.rs

@@ -140,7 +140,7 @@ fn enum_from_ast<'a>(
     variants: &'a Punctuated<syn::Variant, Token![,]>,
     container_default: &attr::Default,
 ) -> Vec<Variant<'a>> {
-    variants
+    let variants: Vec<Variant> = variants
         .iter()
         .map(|variant| {
             let attrs = attr::Variant::from_ast(cx, variant);
@@ -154,7 +154,20 @@ fn enum_from_ast<'a>(
                 original: variant,
             }
         })
-        .collect()
+        .collect();
+
+    let index_of_last_tagged_variant = variants
+        .iter()
+        .rposition(|variant| !variant.attrs.untagged());
+    if let Some(index_of_last_tagged_variant) = index_of_last_tagged_variant {
+        for variant in &variants[..index_of_last_tagged_variant] {
+            if variant.attrs.untagged() {
+                cx.error_spanned_by(&variant.ident, "all variants with the #[serde(untagged)] attribute must be placed at the end of the enum");
+            }
+        }
+    }
+
+    variants
 }
 
 fn struct_from_ast<'a>(

serde_derive/src/internals/check.rs

@@ -3,9 +3,10 @@ use internals::attr::{Identifier, TagType};
 use internals::{ungroup, Ctxt, Derive};
 use syn::{Member, Type};
 
-/// Cross-cutting checks that require looking at more than a single attrs
-/// object. Simpler checks should happen when parsing and building the attrs.
+// Cross-cutting checks that require looking at more than a single attrs object.
+// Simpler checks should happen when parsing and building the attrs.
 pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
+    check_remote_generic(cx, cont);
     check_getter(cx, cont);
     check_flatten(cx, cont);
     check_identifier(cx, cont);
@@ -16,8 +17,30 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     check_from_and_try_from(cx, cont);
 }
 
-/// Getters are only allowed inside structs (not enums) with the `remote`
-/// attribute.
+// Remote derive definition type must have either all of the generics of the
+// remote type:
+//
+//     #[serde(remote = "Generic")]
+//     struct Generic<T> {…}
+//
+// or none of them, i.e. defining impls for one concrete instantiation of the
+// remote type only:
+//
+//     #[serde(remote = "Generic<T>")]
+//     struct ConcreteDef {…}
+//
+fn check_remote_generic(cx: &Ctxt, cont: &Container) {
+    if let Some(remote) = cont.attrs.remote() {
+        let local_has_generic = !cont.generics.params.is_empty();
+        let remote_has_generic = !remote.segments.last().unwrap().arguments.is_none();
+        if local_has_generic && remote_has_generic {
+            cx.error_spanned_by(remote, "remove generic parameters from this path");
+        }
+    }
+}
+
+// Getters are only allowed inside structs (not enums) with the `remote`
+// attribute.
 fn check_getter(cx: &Ctxt, cont: &Container) {
     match cont.data {
         Data::Enum(_) => {
@@ -39,7 +62,7 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Flattening has some restrictions we can test.
+// Flattening has some restrictions we can test.
 fn check_flatten(cx: &Ctxt, cont: &Container) {
     match &cont.data {
         Data::Enum(variants) => {
@@ -78,18 +101,16 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
     }
 }
 
-/// The `other` attribute must be used at most once and it must be the last
-/// variant of an enum.
-///
-/// Inside a `variant_identifier` all variants must be unit variants. Inside a
-/// `field_identifier` all but possibly one variant must be unit variants. The
-/// last variant may be a newtype variant which is an implicit "other" case.
+// The `other` attribute must be used at most once and it must be the last
+// variant of an enum.
+//
+// Inside a `variant_identifier` all variants must be unit variants. Inside a
+// `field_identifier` all but possibly one variant must be unit variants. The
+// last variant may be a newtype variant which is an implicit "other" case.
 fn check_identifier(cx: &Ctxt, cont: &Container) {
     let variants = match &cont.data {
         Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return;
-        }
+        Data::Struct(_, _) => return,
     };
 
     for (i, variant) in variants.iter().enumerate() {
@@ -166,17 +187,15 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Skip-(de)serializing attributes are not allowed on variants marked
-/// (de)serialize_with.
+// Skip-(de)serializing attributes are not allowed on variants marked
+// (de)serialize_with.
 fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
     let variants = match &cont.data {
         Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return;
-        }
+        Data::Struct(_, _) => return,
     };
 
-    for variant in variants.iter() {
+    for variant in variants {
         if variant.attrs.serialize_with().is_some() {
             if variant.attrs.skip_serializing() {
                 cx.error_spanned_by(
@@ -241,10 +260,9 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// The tag of an internally-tagged struct variant must not be
-/// the same as either one of its fields, as this would result in
-/// duplicate keys in the serialized output and/or ambiguity in
-/// the to-be-deserialized input.
+// The tag of an internally-tagged struct variant must not be the same as either
+// one of its fields, as this would result in duplicate keys in the serialized
+// output and/or ambiguity in the to-be-deserialized input.
 fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
     let variants = match &cont.data {
         Data::Enum(variants) => variants,
@@ -290,8 +308,8 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// In the case of adjacently-tagged enums, the type and the
-/// contents tag must differ, for the same reason.
+// In the case of adjacently-tagged enums, the type and the contents tag must
+// differ, for the same reason.
 fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
     let (type_tag, content_tag) = match cont.attrs.tag() {
         TagType::Adjacent { tag, content } => (tag, content),
@@ -309,7 +327,7 @@ fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Enums and unit structs cannot be transparent.
+// Enums and unit structs cannot be transparent.
 fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     if !cont.attrs.transparent() {
         return;

serde_derive/src/internals/ctxt.rs

@@ -44,12 +44,19 @@ impl Ctxt {
     }
 
     /// Consume this object, producing a formatted error string if there are errors.
-    pub fn check(self) -> Result<(), Vec<syn::Error>> {
-        let errors = self.errors.borrow_mut().take().unwrap();
-        match errors.len() {
-            0 => Ok(()),
-            _ => Err(errors),
+    pub fn check(self) -> syn::Result<()> {
+        let mut errors = self.errors.borrow_mut().take().unwrap().into_iter();
+
+        let mut combined = match errors.next() {
+            Some(first) => first,
+            None => return Ok(()),
+        };
+
+        for rest in errors {
+            combined.combine(rest);
         }
+
+        Err(combined)
     }
 }
 

serde_derive/src/internals/receiver.rs

@@ -179,10 +179,13 @@ impl ReplaceReceiver<'_> {
                 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::AssocType(arg) => self.visit_type_mut(&mut arg.ty),
                         GenericArgument::Lifetime(_)
-                        | GenericArgument::Constraint(_)
-                        | GenericArgument::Const(_) => {}
+                        | GenericArgument::Const(_)
+                        | GenericArgument::AssocConst(_)
+                        | GenericArgument::Constraint(_) => {}
+                        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                        _ => {}
                     }
                 }
             }
@@ -205,7 +208,9 @@ impl ReplaceReceiver<'_> {
     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(_) => {}
+            TypeParamBound::Lifetime(_) | TypeParamBound::Verbatim(_) => {}
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => {}
         }
     }
 
@@ -229,7 +234,9 @@ impl ReplaceReceiver<'_> {
                             self.visit_type_param_bound_mut(bound);
                         }
                     }
-                    WherePredicate::Lifetime(_) | WherePredicate::Eq(_) => {}
+                    WherePredicate::Lifetime(_) => {}
+                    #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                    _ => {}
                 }
             }
         }

serde_derive/src/internals/symbol.rs

@@ -13,6 +13,7 @@ pub const DEFAULT: Symbol = Symbol("default");
 pub const DENY_UNKNOWN_FIELDS: Symbol = Symbol("deny_unknown_fields");
 pub const DESERIALIZE: Symbol = Symbol("deserialize");
 pub const DESERIALIZE_WITH: Symbol = Symbol("deserialize_with");
+pub const EXPECTING: Symbol = Symbol("expecting");
 pub const FIELD_IDENTIFIER: Symbol = Symbol("field_identifier");
 pub const FLATTEN: Symbol = Symbol("flatten");
 pub const FROM: Symbol = Symbol("from");
@@ -22,6 +23,7 @@ pub const OTHER: Symbol = Symbol("other");
 pub const REMOTE: Symbol = Symbol("remote");
 pub const RENAME: Symbol = Symbol("rename");
 pub const RENAME_ALL: Symbol = Symbol("rename_all");
+pub const REPR: Symbol = Symbol("repr");
 pub const SERDE: Symbol = Symbol("serde");
 pub const SERIALIZE: Symbol = Symbol("serialize");
 pub const SERIALIZE_WITH: Symbol = Symbol("serialize_with");
@@ -35,7 +37,6 @@ 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,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.140")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.165")]
 #![allow(unknown_lints, bare_trait_objects)]
 // Ignored clippy lints
 #![allow(
@@ -43,7 +43,7 @@
     clippy::enum_glob_use,
     clippy::indexing_slicing,
     clippy::items_after_statements,
-    clippy::let_underscore_drop,
+    clippy::let_underscore_untyped,
     clippy::manual_assert,
     clippy::map_err_ignore,
     clippy::match_same_arms,
@@ -85,13 +85,14 @@ mod de;
 mod dummy;
 mod pretend;
 mod ser;
+mod this;
 mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as DeriveInput);
     ser::expand_derive_serialize(&mut input)
-        .unwrap_or_else(to_compile_errors)
+        .unwrap_or_else(syn::Error::into_compile_error)
         .into()
 }
 
@@ -99,11 +100,6 @@ pub fn derive_serialize(input: TokenStream) -> TokenStream {
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as DeriveInput);
     de::expand_derive_deserialize(&mut input)
-        .unwrap_or_else(to_compile_errors)
+        .unwrap_or_else(syn::Error::into_compile_error)
         .into()
 }
-
-fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
-    let compile_errors = errors.iter().map(syn::Error::to_compile_error);
-    quote!(#(#compile_errors)*)
-}

serde_derive/src/pretend.rs

@@ -97,29 +97,14 @@ fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> Toke
 
     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),* }) => {}
-                _ => {}
+    quote! {
+        match _serde::__private::None::<&#type_ident #ty_generics> {
+            _serde::__private::Some(__v @ #type_ident { #(#members: _),* }) => {
+                #(
+                    let _ = _serde::__private::ptr::addr_of!(__v.#members);
+                )*
             }
+            _ => {}
         }
     }
 }

serde_derive/src/ser.rs

@@ -8,10 +8,9 @@ use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, replace_receiver, Ctxt, Derive};
 use pretend;
+use this;
 
-pub fn expand_derive_serialize(
-    input: &mut syn::DeriveInput,
-) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<TokenStream> {
     replace_receiver(input);
 
     let ctxt = Ctxt::new();
@@ -58,8 +57,6 @@ pub fn expand_derive_serialize(
 
     Ok(dummy::wrap_in_const(
         cont.attrs.custom_serde_path(),
-        "SERIALIZE",
-        ident,
         impl_block,
     ))
 }
@@ -82,9 +79,13 @@ struct Parameters {
     self_var: Ident,
 
     /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
+    /// types (does not include generic parameters) or `some::remote::Path` for
+    /// remote types.
+    this_type: syn::Path,
+
+    /// Same as `this_type` but using `::<T>` for generic parameters for use in
+    /// expression position.
+    this_value: syn::Path,
 
     /// Generics including any explicit and inferred bounds for the impl.
     generics: syn::Generics,
@@ -105,18 +106,15 @@ impl Parameters {
             Ident::new("self", Span::call_site())
         };
 
-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
-
+        let this_type = this::this_type(cont);
+        let this_value = this::this_value(cont);
         let is_packed = cont.attrs.is_packed();
-
         let generics = build_generics(cont);
 
         Parameters {
             self_var,
-            this,
+            this_type,
+            this_value,
             generics,
             is_remote,
             is_packed,
@@ -126,7 +124,7 @@ impl Parameters {
     /// Type name to use in error messages and `&'static str` arguments to
     /// various Serializer methods.
     fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
+        self.this_type.segments.last().unwrap().ident.to_string()
     }
 }
 
@@ -427,7 +425,7 @@ fn serialize_variant(
     variant_index: u32,
     cattrs: &attr::Container,
 ) -> TokenStream {
-    let this = &params.this;
+    let this_value = &params.this_value;
     let variant_ident = &variant.ident;
 
     if variant.attrs.skip_serializing() {
@@ -445,47 +443,49 @@ fn serialize_variant(
             Style::Struct => quote!({ .. }),
         };
         quote! {
-            #this::#variant_ident #fields_pat => #skipped_err,
+            #this_value::#variant_ident #fields_pat => #skipped_err,
         }
     } else {
         // variant wasn't skipped
         let case = match variant.style {
             Style::Unit => {
                 quote! {
-                    #this::#variant_ident
+                    #this_value::#variant_ident
                 }
             }
             Style::Newtype => {
                 quote! {
-                    #this::#variant_ident(ref __field0)
+                    #this_value::#variant_ident(ref __field0)
                 }
             }
             Style::Tuple => {
                 let field_names = (0..variant.fields.len())
                     .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                 quote! {
-                    #this::#variant_ident(#(ref #field_names),*)
+                    #this_value::#variant_ident(#(ref #field_names),*)
                 }
             }
             Style::Struct => {
                 let members = variant.fields.iter().map(|f| &f.member);
                 quote! {
-                    #this::#variant_ident { #(ref #members),* }
+                    #this_value::#variant_ident { #(ref #members),* }
                 }
             }
         };
 
-        let body = Match(match cattrs.tag() {
-            attr::TagType::External => {
+        let body = Match(match (cattrs.tag(), variant.attrs.untagged()) {
+            (attr::TagType::External, false) => {
                 serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
             }
-            attr::TagType::Internal { tag } => {
+            (attr::TagType::Internal { tag }, false) => {
                 serialize_internally_tagged_variant(params, variant, cattrs, tag)
             }
-            attr::TagType::Adjacent { tag, content } => {
+            (attr::TagType::Adjacent { tag, content }, false) => {
                 serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content)
             }
-            attr::TagType::None => serialize_untagged_variant(params, variant, cattrs),
+            (attr::TagType::None, _) | (_, true) => {
+                serialize_untagged_variant(params, variant, cattrs)
+            }
         });
 
         quote! {
@@ -640,7 +640,7 @@ fn serialize_adjacently_tagged_variant(
     tag: &str,
     content: &str,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let type_name = cattrs.name().serialize_name();
     let variant_name = variant.attrs.name().serialize_name();
 
@@ -717,9 +717,10 @@ fn serialize_adjacently_tagged_variant(
     let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
 
     quote_block! {
+        #[doc(hidden)]
         struct __AdjacentlyTagged #wrapper_generics #where_clause {
             data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
@@ -741,7 +742,7 @@ fn serialize_adjacently_tagged_variant(
         try!(_serde::ser::SerializeStruct::serialize_field(
             &mut __struct, #content, &__AdjacentlyTagged {
                 data: (#(#fields_ident,)*),
-                phantom: _serde::__private::PhantomData::<#this #ty_generics>,
+                phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
             }));
         _serde::ser::SerializeStruct::end(__struct)
     }
@@ -866,8 +867,8 @@ enum StructVariant<'a> {
     Untagged,
 }
 
-fn serialize_struct_variant<'a>(
-    context: StructVariant<'a>,
+fn serialize_struct_variant(
+    context: StructVariant,
     params: &Parameters,
     fields: &[Field],
     name: &str,
@@ -950,8 +951,8 @@ fn serialize_struct_variant<'a>(
     }
 }
 
-fn serialize_struct_variant_with_flatten<'a>(
-    context: StructVariant<'a>,
+fn serialize_struct_variant_with_flatten(
+    context: StructVariant,
     params: &Parameters,
     fields: &[Field],
     name: &str,
@@ -971,7 +972,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             variant_index,
             variant_name,
         } => {
-            let this = &params.this;
+            let this_type = &params.this_type;
             let fields_ty = fields.iter().map(|f| &f.ty);
             let members = &fields.iter().map(|f| &f.member).collect::<Vec<_>>();
 
@@ -980,9 +981,10 @@ fn serialize_struct_variant_with_flatten<'a>(
             let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
 
             quote_block! {
+                #[doc(hidden)]
                 struct __EnumFlatten #wrapper_generics #where_clause {
                     data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::__private::PhantomData<#this #ty_generics>,
+                    phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
                 }
 
                 impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
@@ -1006,7 +1008,7 @@ fn serialize_struct_variant_with_flatten<'a>(
                     #variant_name,
                     &__EnumFlatten {
                         data: (#(#members,)*),
-                        phantom: _serde::__private::PhantomData::<#this #ty_generics>,
+                        phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
                     })
             }
         }
@@ -1192,7 +1194,7 @@ fn wrap_serialize_with(
     field_tys: &[&syn::Type],
     field_exprs: &[TokenStream],
 ) -> TokenStream {
-    let this = &params.this;
+    let this_type = &params.this_type;
     let (_, ty_generics, where_clause) = params.generics.split_for_impl();
 
     let wrapper_generics = if field_exprs.is_empty() {
@@ -1210,9 +1212,10 @@ fn wrap_serialize_with(
     });
 
     quote!({
+        #[doc(hidden)]
         struct __SerializeWith #wrapper_impl_generics #where_clause {
             values: (#(&'__a #field_tys, )*),
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
@@ -1226,7 +1229,7 @@ fn wrap_serialize_with(
 
         &__SerializeWith {
             values: (#(#field_exprs, )*),
-            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
         }
     })
 }

serde_derive/src/this.rs

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

serde_derive_internals/.clippy.toml

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

serde_derive_internals/Cargo.toml

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

serde_derive_internals/build.rs

@@ -1,6 +1,9 @@
 use std::path::Path;
 
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=src/mod.rs");
+
     // 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

serde_derive_internals/lib.rs

@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.26.0")]
+#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.28.0")]
 #![allow(unknown_lints, bare_trait_objects)]
 // Ignored clippy lints
 #![allow(
@@ -22,7 +22,7 @@
     clippy::doc_markdown,
     clippy::enum_glob_use,
     clippy::items_after_statements,
-    clippy::let_underscore_drop,
+    clippy::let_underscore_untyped,
     clippy::manual_assert,
     clippy::match_same_arms,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
@@ -31,6 +31,7 @@
     clippy::module_name_repetitions,
     clippy::must_use_candidate,
     clippy::similar_names,
+    clippy::single_match_else,
     clippy::struct_excessive_bools,
     clippy::too_many_lines,
     clippy::unused_self,

serde_test/.clippy.toml

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

serde_test/Cargo.toml

@@ -1,17 +1,18 @@
 [package]
 name = "serde_test"
-version = "1.0.140" # remember to update html_root_url
+version = "1.0.165" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.13"
-license = "MIT OR Apache-2.0"
-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"]
-readme = "crates-io.md"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 build = "build.rs"
+categories = ["development-tools::testing"]
+description = "Token De/Serializer for testing De/Serialize implementations"
+documentation = "https://docs.rs/serde_test"
+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"
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.19"
 
 [dependencies]
 serde = { version = "1.0.60", path = "../serde" }
@@ -20,5 +21,8 @@ serde = { version = "1.0.60", path = "../serde" }
 serde = { version = "1.0", path = "../serde" }
 serde_derive = { version = "1.0", path = "../serde_derive" }
 
+[lib]
+doc-scrape-examples = false
+
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

serde_test/build.rs

@@ -6,6 +6,8 @@ use std::str::{self, FromStr};
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
     let minor = match rustc_minor_version() {
         Some(minor) => minor,
         None => return,
@@ -13,8 +15,8 @@ fn main() {
 
     // #[track_caller] stabilized in Rust 1.46:
     // https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html#track_caller
-    if minor >= 46 {
-        println!("cargo:rustc-cfg=track_caller");
+    if minor < 46 {
+        println!("cargo:rustc-cfg=no_track_caller");
     }
 }
 

serde_test/src/assert.rs

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

serde_test/src/de.rs

@@ -12,32 +12,29 @@ pub struct Deserializer<'de> {
     tokens: &'de [Token],
 }
 
-macro_rules! assert_next_token {
-    ($de:expr, $expected:expr) => {
-        match $de.next_token_opt() {
-            Some(token) if token == $expected => {}
-            Some(other) => panic!(
-                "expected Token::{} but deserialization wants Token::{}",
-                other, $expected
-            ),
-            None => panic!(
-                "end of tokens but deserialization wants Token::{}",
-                $expected
-            ),
-        }
-    };
+fn assert_next_token(de: &mut Deserializer, expected: Token) -> Result<(), Error> {
+    match de.next_token_opt() {
+        Some(token) if token == expected => Ok(()),
+        Some(other) => Err(de::Error::custom(format!(
+            "expected Token::{} but deserialization wants Token::{}",
+            other, expected,
+        ))),
+        None => Err(de::Error::custom(format!(
+            "end of tokens but deserialization wants Token::{}",
+            expected,
+        ))),
+    }
 }
 
-macro_rules! unexpected {
-    ($token:expr) => {
-        panic!("deserialization did not expect this token: {}", $token)
-    };
+fn unexpected(token: Token) -> Error {
+    de::Error::custom(format!(
+        "deserialization did not expect this token: {}",
+        token,
+    ))
 }
 
-macro_rules! end_of_tokens {
-    () => {
-        panic!("ran out of tokens to deserialize")
-    };
+fn end_of_tokens() -> Error {
+    de::Error::custom("ran out of tokens to deserialize")
 }
 
 impl<'de> Deserializer<'de> {
@@ -49,11 +46,8 @@ impl<'de> Deserializer<'de> {
         self.tokens.first().cloned()
     }
 
-    fn peek_token(&self) -> Token {
-        match self.peek_token_opt() {
-            Some(token) => token,
-            None => end_of_tokens!(),
-        }
+    fn peek_token(&self) -> Result<Token, Error> {
+        self.peek_token_opt().ok_or_else(end_of_tokens)
     }
 
     pub fn next_token_opt(&mut self) -> Option<Token> {
@@ -66,14 +60,10 @@ impl<'de> Deserializer<'de> {
         }
     }
 
-    fn next_token(&mut self) -> Token {
-        match self.tokens.split_first() {
-            Some((&first, rest)) => {
-                self.tokens = rest;
-                first
-            }
-            None => end_of_tokens!(),
-        }
+    fn next_token(&mut self) -> Result<Token, Error> {
+        let (&first, rest) = self.tokens.split_first().ok_or_else(end_of_tokens)?;
+        self.tokens = rest;
+        Ok(first)
     }
 
     pub fn remaining(&self) -> usize {
@@ -94,7 +84,7 @@ impl<'de> Deserializer<'de> {
             len: len,
             end: end,
         })?;
-        assert_next_token!(self, end);
+        assert_next_token(self, end)?;
         Ok(value)
     }
 
@@ -112,7 +102,7 @@ impl<'de> Deserializer<'de> {
             len: len,
             end: end,
         })?;
-        assert_next_token!(self, end);
+        assert_next_token(self, end)?;
         Ok(value)
     }
 }
@@ -129,7 +119,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        let token = self.next_token();
+        let token = self.next_token()?;
         match token {
             Token::Bool(v) => visitor.visit_bool(v),
             Token::I8(v) => visitor.visit_i8(v),
@@ -161,50 +151,50 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor),
             Token::Struct { len, .. } => self.visit_map(Some(len), Token::StructEnd, visitor),
             Token::Enum { .. } => {
-                let variant = self.next_token();
-                let next = self.peek_token();
+                let variant = self.next_token()?;
+                let next = self.peek_token()?;
                 match (variant, next) {
                     (Token::Str(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_str(variant)
                     }
                     (Token::BorrowedStr(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_borrowed_str(variant)
                     }
                     (Token::String(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_string(variant.to_string())
                     }
                     (Token::Bytes(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_bytes(variant)
                     }
                     (Token::BorrowedBytes(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_borrowed_bytes(variant)
                     }
                     (Token::ByteBuf(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_byte_buf(variant.to_vec())
                     }
                     (Token::U8(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_u8(variant)
                     }
                     (Token::U16(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_u16(variant)
                     }
                     (Token::U32(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_u32(variant)
                     }
                     (Token::U64(variant), Token::Unit) => {
-                        self.next_token();
+                        self.next_token()?;
                         visitor.visit_u64(variant)
                     }
-                    (variant, Token::Unit) => unexpected!(variant),
+                    (variant, Token::Unit) => Err(unexpected(variant)),
                     (variant, _) => {
                         visitor.visit_map(EnumMapVisitor::new(self, variant, EnumFormat::Any))
                     }
@@ -232,9 +222,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             | Token::MapEnd
             | Token::StructEnd
             | Token::TupleVariantEnd
-            | Token::StructVariantEnd => {
-                unexpected!(token);
-            }
+            | Token::StructVariantEnd => Err(unexpected(token)),
         }
     }
 
@@ -242,13 +230,13 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::Unit | Token::None => {
-                self.next_token();
+                self.next_token()?;
                 visitor.visit_none()
             }
             Token::Some => {
-                self.next_token();
+                self.next_token()?;
                 visitor.visit_some(self)
             }
             _ => self.deserialize_any(visitor),
@@ -264,9 +252,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::Enum { name: n } if name == n => {
-                self.next_token();
+                self.next_token()?;
 
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
@@ -286,9 +274,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::UnitStruct { .. } => {
-                assert_next_token!(self, Token::UnitStruct { name: name });
+                assert_next_token(self, Token::UnitStruct { name: name })?;
                 visitor.visit_unit()
             }
             _ => self.deserialize_any(visitor),
@@ -303,9 +291,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::NewtypeStruct { .. } => {
-                assert_next_token!(self, Token::NewtypeStruct { name: name });
+                assert_next_token(self, Token::NewtypeStruct { name: name })?;
                 visitor.visit_newtype_struct(self)
             }
             _ => self.deserialize_any(visitor),
@@ -316,21 +304,21 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::Unit | Token::UnitStruct { .. } => {
-                self.next_token();
+                self.next_token()?;
                 visitor.visit_unit()
             }
             Token::Seq { .. } => {
-                self.next_token();
+                self.next_token()?;
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
             Token::Tuple { .. } => {
-                self.next_token();
+                self.next_token()?;
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
             Token::TupleStruct { .. } => {
-                self.next_token();
+                self.next_token()?;
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
             _ => self.deserialize_any(visitor),
@@ -346,25 +334,25 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::Unit => {
-                self.next_token();
+                self.next_token()?;
                 visitor.visit_unit()
             }
             Token::UnitStruct { .. } => {
-                assert_next_token!(self, Token::UnitStruct { name: name });
+                assert_next_token(self, Token::UnitStruct { name: name })?;
                 visitor.visit_unit()
             }
             Token::Seq { .. } => {
-                self.next_token();
+                self.next_token()?;
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
             Token::Tuple { .. } => {
-                self.next_token();
+                self.next_token()?;
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
             Token::TupleStruct { len: n, .. } => {
-                assert_next_token!(self, Token::TupleStruct { name: name, len: n });
+                assert_next_token(self, Token::TupleStruct { name: name, len: n })?;
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
             _ => self.deserialize_any(visitor),
@@ -380,13 +368,13 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.peek_token() {
+        match self.peek_token()? {
             Token::Struct { len: n, .. } => {
-                assert_next_token!(self, Token::Struct { name: name, len: n });
+                assert_next_token(self, Token::Struct { name: name, len: n })?;
                 self.visit_map(Some(fields.len()), Token::StructEnd, visitor)
             }
             Token::Map { .. } => {
-                self.next_token();
+                self.next_token()?;
                 self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
             }
             _ => self.deserialize_any(visitor),
@@ -476,7 +464,7 @@ impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
     where
         V: DeserializeSeed<'de>,
     {
-        match self.de.peek_token() {
+        match self.de.peek_token()? {
             Token::UnitVariant { variant: v, .. }
             | Token::NewtypeVariant { variant: v, .. }
             | Token::TupleVariant { variant: v, .. }
@@ -497,9 +485,9 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
     type Error = Error;
 
     fn unit_variant(self) -> Result<(), Error> {
-        match self.de.peek_token() {
+        match self.de.peek_token()? {
             Token::UnitVariant { .. } => {
-                self.de.next_token();
+                self.de.next_token()?;
                 Ok(())
             }
             _ => Deserialize::deserialize(self.de),
@@ -510,9 +498,9 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
     where
         T: DeserializeSeed<'de>,
     {
-        match self.de.peek_token() {
+        match self.de.peek_token()? {
             Token::NewtypeVariant { .. } => {
-                self.de.next_token();
+                self.de.next_token()?;
                 seed.deserialize(self.de)
             }
             _ => seed.deserialize(self.de),
@@ -523,26 +511,26 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
     where
         V: Visitor<'de>,
     {
-        match self.de.peek_token() {
+        match self.de.peek_token()? {
             Token::TupleVariant { len: enum_len, .. } => {
-                let token = self.de.next_token();
+                let token = self.de.next_token()?;
 
                 if len == enum_len {
                     self.de
                         .visit_seq(Some(len), Token::TupleVariantEnd, visitor)
                 } else {
-                    unexpected!(token);
+                    Err(unexpected(token))
                 }
             }
             Token::Seq {
                 len: Some(enum_len),
             } => {
-                let token = self.de.next_token();
+                let token = self.de.next_token()?;
 
                 if len == enum_len {
                     self.de.visit_seq(Some(len), Token::SeqEnd, visitor)
                 } else {
-                    unexpected!(token);
+                    Err(unexpected(token))
                 }
             }
             _ => de::Deserializer::deserialize_any(self.de, visitor),
@@ -557,27 +545,27 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
     where
         V: Visitor<'de>,
     {
-        match self.de.peek_token() {
+        match self.de.peek_token()? {
             Token::StructVariant { len: enum_len, .. } => {
-                let token = self.de.next_token();
+                let token = self.de.next_token()?;
 
                 if fields.len() == enum_len {
                     self.de
                         .visit_map(Some(fields.len()), Token::StructVariantEnd, visitor)
                 } else {
-                    unexpected!(token);
+                    Err(unexpected(token))
                 }
             }
             Token::Map {
                 len: Some(enum_len),
             } => {
-                let token = self.de.next_token();
+                let token = self.de.next_token()?;
 
                 if fields.len() == enum_len {
                     self.de
                         .visit_map(Some(fields.len()), Token::MapEnd, visitor)
                 } else {
-                    unexpected!(token);
+                    Err(unexpected(token))
                 }
             }
             _ => de::Deserializer::deserialize_any(self.de, visitor),
@@ -622,7 +610,7 @@ impl<'de, 'a> MapAccess<'de> for EnumMapVisitor<'a, 'de> {
                 .deserialize(BytesDeserializer { value: variant })
                 .map(Some),
             Some(Token::U32(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
-            Some(other) => unexpected!(other),
+            Some(other) => Err(unexpected(other)),
             None => Ok(None),
         }
     }
@@ -641,7 +629,7 @@ impl<'de, 'a> MapAccess<'de> for EnumMapVisitor<'a, 'de> {
                     };
                     seed.deserialize(SeqAccessDeserializer::new(visitor))?
                 };
-                assert_next_token!(self.de, Token::TupleVariantEnd);
+                assert_next_token(self.de, Token::TupleVariantEnd)?;
                 Ok(value)
             }
             EnumFormat::Map => {
@@ -653,7 +641,7 @@ impl<'de, 'a> MapAccess<'de> for EnumMapVisitor<'a, 'de> {
                     };
                     seed.deserialize(MapAccessDeserializer::new(visitor))?
                 };
-                assert_next_token!(self.de, Token::StructVariantEnd);
+                assert_next_token(self.de, Token::StructVariantEnd)?;
                 Ok(value)
             }
             EnumFormat::Any => seed.deserialize(&mut *self.de),

serde_test/src/lib.rs

@@ -1,8 +1,8 @@
 //! This crate provides a convenient concise way to write unit tests for
 //! implementations of [`Serialize`] and [`Deserialize`].
 //!
-//! [`Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
-//! [`Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
+//! [`Serialize`]: serde::ser::Serialize
+//! [`Deserialize`]: serde::de::Deserialize
 //!
 //! The `Serialize` impl for a value can be characterized by the sequence of
 //! [`Serializer`] calls that are made in the course of serializing the value,
@@ -14,11 +14,7 @@
 //! test both directions. There are also functions to test expected failure
 //! conditions.
 //!
-//! [`Serializer`]: https://docs.serde.rs/serde/ser/trait.Serializer.html
-//! [`Token`]: https://docs.serde.rs/serde_test/enum.Token.html
-//! [`assert_ser_tokens`]: https://docs.serde.rs/serde_test/fn.assert_ser_tokens.html
-//! [`assert_de_tokens`]: https://docs.serde.rs/serde_test/fn.assert_de_tokens.html
-//! [`assert_tokens`]: https://docs.serde.rs/serde_test/fn.assert_tokens.html
+//! [`Serializer`]: serde::ser::Serializer
 //!
 //! Here is an example from the [`linked-hash-map`] crate.
 //!
@@ -144,7 +140,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.140")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.165")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
@@ -186,7 +182,3 @@ pub use assert::{
 pub use token::Token;
 
 pub use configure::{Compact, Configure, Readable};
-
-// Not public API.
-#[doc(hidden)]
-pub use de::Deserializer;

serde_test/src/ser.rs

@@ -63,14 +63,12 @@ macro_rules! assert_next_token {
     ($ser:expr, $actual:expr, $pat:pat, $guard:expr) => {
         match $ser.next_token() {
             Some($pat) if $guard => {}
-            Some(expected) => {
-                panic!("expected Token::{} but serialized as {}",
-                       expected, $actual);
-            }
-            None => {
-                panic!("expected end of tokens, but {} was serialized",
-                       $actual);
-            }
+            Some(expected) => return Err(ser::Error::custom(
+                format!("expected Token::{} but serialized as {}", expected, $actual)
+            )),
+            None => return Err(ser::Error::custom(
+                format!("expected end of tokens, but {} was serialized", $actual)
+            )),
         }
     };
 }

test_suite/Cargo.toml

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

test_suite/build.rs

@@ -1,25 +0,0 @@
-use std::process::{Command, ExitStatus, Stdio};
-
-fn has_cargo_expand() -> bool {
-    let cargo_expand = if cfg!(windows) {
-        "cargo-expand.exe"
-    } else {
-        "cargo-expand"
-    };
-
-    Command::new(cargo_expand)
-        .arg("--version")
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .status()
-        .as_ref()
-        .map(ExitStatus::success)
-        .unwrap_or(false)
-}
-
-fn main() {
-    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/expand/de_enum.rs

@@ -1,13 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-enum DeEnum<B, C, D> {
-    Unit,
-    Seq(i8, B, C, D),
-    Map { a: i8, b: B, c: C, d: D },
-
-    // Make sure we can support more than one variant.
-    _Unit2,
-    _Seq2(i8, B, C, D),
-    _Map2 { a: i8, b: B, c: C, d: D },
-}

test_suite/tests/expand/default_ty_param.expanded.rs

@@ -1,448 +0,0 @@
-use serde::{Deserialize, Serialize};
-trait AssociatedType {
-    type X;
-}
-impl AssociatedType for i32 {
-    type X = i32;
-}
-struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
-    phantom: PhantomData<T>,
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            let mut __serde_state = match _serde::Serializer::serialize_struct(
-                __serializer,
-                "DefaultTyParam",
-                false as usize + 1,
-            ) {
-                _serde::__private::Ok(__val) => __val,
-                _serde::__private::Err(__err) => {
-                    return _serde::__private::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeStruct::serialize_field(
-                &mut __serde_state,
-                "phantom",
-                &self.phantom,
-            ) {
-                _serde::__private::Ok(__val) => __val,
-                _serde::__private::Err(__err) => {
-                    return _serde::__private::Err(__err);
-                }
-            };
-            _serde::ser::SerializeStruct::end(__serde_state)
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de>
-    for DefaultTyParam<T> {
-        fn deserialize<__D>(
-            __deserializer: __D,
-        ) -> _serde::__private::Result<Self, __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __ignore,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "field identifier",
-                    )
-                }
-                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::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _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> {
-                type Value = DefaultTyParam<T>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "struct DefaultTyParam",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    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);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            return _serde::__private::Err(
-                                _serde::de::Error::invalid_length(
-                                    0usize,
-                                    &"struct DefaultTyParam with 1 element",
-                                ),
-                            );
-                        }
-                    };
-                    _serde::__private::Ok(DefaultTyParam {
-                        phantom: __field0,
-                    })
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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) {
-                            _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(
-                                            "phantom",
-                                        ),
-                                    );
-                                }
-                                __field0 = _serde::__private::Some(
-                                    match _serde::de::MapAccess::next_value::<
-                                        PhantomData<T>,
-                                    >(&mut __map) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    let __field0 = match __field0 {
-                        _serde::__private::Some(__field0) => __field0,
-                        _serde::__private::None => {
-                            match _serde::__private::de::missing_field("phantom") {
-                                _serde::__private::Ok(__val) => __val,
-                                _serde::__private::Err(__err) => {
-                                    return _serde::__private::Err(__err);
-                                }
-                            }
-                        }
-                    };
-                    _serde::__private::Ok(DefaultTyParam {
-                        phantom: __field0,
-                    })
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["phantom"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DefaultTyParam",
-                FIELDS,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<DefaultTyParam<T>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __ignore,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "field identifier",
-                    )
-                }
-                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::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _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> {
-                type Value = ();
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "struct DefaultTyParam",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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",
-                            ),
-                        );
-                    }
-                    _serde::__private::Ok(())
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __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) {
-                            _serde::__private::Ok(__val) => __val,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
-                            }
-                        } {
-                        match __key {
-                            __Field::__field0 => {
-                                if __field0 {
-                                    return _serde::__private::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field(
-                                            "phantom",
-                                        ),
-                                    );
-                                }
-                                match _serde::de::MapAccess::next_value_seed(
-                                    &mut __map,
-                                    _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
-                                ) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                                __field0 = true;
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if !__field0 {
-                        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(())
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["phantom"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DefaultTyParam",
-                FIELDS,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/default_ty_param.rs

@@ -1,14 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-trait AssociatedType {
-    type X;
-}
-
-impl AssociatedType for i32 {
-    type X = i32;
-}
-
-#[derive(Serialize, Deserialize)]
-struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
-    phantom: PhantomData<T>,
-}

test_suite/tests/expand/generic_enum.expanded.rs

@@ -1,621 +0,0 @@
-use serde::{Deserialize, Serialize};
-pub enum GenericEnum<T, U> {
-    Unit,
-    NewType(T),
-    Seq(T, U),
-    Map { x: T, y: U },
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<T, U> _serde::Serialize for GenericEnum<T, U>
-    where
-        T: _serde::Serialize,
-        U: _serde::Serialize,
-    {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            match *self {
-                GenericEnum::Unit => {
-                    _serde::Serializer::serialize_unit_variant(
-                        __serializer,
-                        "GenericEnum",
-                        0u32,
-                        "Unit",
-                    )
-                }
-                GenericEnum::NewType(ref __field0) => {
-                    _serde::Serializer::serialize_newtype_variant(
-                        __serializer,
-                        "GenericEnum",
-                        1u32,
-                        "NewType",
-                        __field0,
-                    )
-                }
-                GenericEnum::Seq(ref __field0, ref __field1) => {
-                    let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
-                        __serializer,
-                        "GenericEnum",
-                        2u32,
-                        "Seq",
-                        0 + 1 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field0,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeTupleVariant::end(__serde_state)
-                }
-                GenericEnum::Map { ref x, ref y } => {
-                    let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
-                        __serializer,
-                        "GenericEnum",
-                        3u32,
-                        "Map",
-                        0 + 1 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "x",
-                        x,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "y",
-                        y,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-            }
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-    where
-        T: _serde::Deserialize<'de>,
-        U: _serde::Deserialize<'de>,
-    {
-        fn deserialize<__D>(
-            __deserializer: __D,
-        ) -> _serde::__private::Result<Self, __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __field1,
-                __field2,
-                __field3,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "variant identifier",
-                    )
-                }
-                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),
-                        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",
-                                ),
-                            )
-                        }
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "Unit" => _serde::__private::Ok(__Field::__field0),
-                        "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),
-                            )
-                        }
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"Unit" => _serde::__private::Ok(__Field::__field0),
-                        b"NewType" => _serde::__private::Ok(__Field::__field1),
-                        b"Seq" => _serde::__private::Ok(__Field::__field2),
-                        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),
-                            )
-                        }
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de, T, U>
-            where
-                T: _serde::Deserialize<'de>,
-                U: _serde::Deserialize<'de>,
-            {
-                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>
-            where
-                T: _serde::Deserialize<'de>,
-                U: _serde::Deserialize<'de>,
-            {
-                type Value = GenericEnum<T, U>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "enum GenericEnum",
-                    )
-                }
-                fn visit_enum<__A>(
-                    self,
-                    __data: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::EnumAccess<'de>,
-                {
-                    match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        (__Field::__field0, __variant) => {
-                            match _serde::de::VariantAccess::unit_variant(__variant) {
-                                _serde::__private::Ok(__val) => __val,
-                                _serde::__private::Err(__err) => {
-                                    return _serde::__private::Err(__err);
-                                }
-                            };
-                            _serde::__private::Ok(GenericEnum::Unit)
-                        }
-                        (__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
-                                T: _serde::Deserialize<'de>,
-                                U: _serde::Deserialize<'de>,
-                            {
-                                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>
-                            where
-                                T: _serde::Deserialize<'de>,
-                                U: _serde::Deserialize<'de>,
-                            {
-                                type Value = GenericEnum<T, U>;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result {
-                                    _serde::__private::Formatter::write_str(
-                                        __formatter,
-                                        "tuple variant GenericEnum::Seq",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    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);
-                                        }
-                                    } {
-                                        _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",
-                                                ),
-                                            );
-                                        }
-                                    };
-                                    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);
-                                        }
-                                    } {
-                                        _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",
-                                                ),
-                                            );
-                                        }
-                                    };
-                                    _serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
-                                }
-                            }
-                            _serde::de::VariantAccess::tuple_variant(
-                                __variant,
-                                2usize,
-                                __Visitor {
-                                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::__private::PhantomData,
-                                },
-                            )
-                        }
-                        (__Field::__field3, __variant) => {
-                            #[allow(non_camel_case_types)]
-                            enum __Field {
-                                __field0,
-                                __field1,
-                                __ignore,
-                            }
-                            struct __FieldVisitor;
-                            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                                type Value = __Field;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result {
-                                    _serde::__private::Formatter::write_str(
-                                        __formatter,
-                                        "field identifier",
-                                    )
-                                }
-                                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),
-                                        1u64 => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_str<__E>(
-                                    self,
-                                    __value: &str,
-                                ) -> _serde::__private::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        "x" => _serde::__private::Ok(__Field::__field0),
-                                        "y" => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_bytes<__E>(
-                                    self,
-                                    __value: &[u8],
-                                ) -> _serde::__private::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        b"x" => _serde::__private::Ok(__Field::__field0),
-                                        b"y" => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                            }
-                            impl<'de> _serde::Deserialize<'de> for __Field {
-                                #[inline]
-                                fn deserialize<__D>(
-                                    __deserializer: __D,
-                                ) -> _serde::__private::Result<Self, __D::Error>
-                                where
-                                    __D: _serde::Deserializer<'de>,
-                                {
-                                    _serde::Deserializer::deserialize_identifier(
-                                        __deserializer,
-                                        __FieldVisitor,
-                                    )
-                                }
-                            }
-                            struct __Visitor<'de, T, U>
-                            where
-                                T: _serde::Deserialize<'de>,
-                                U: _serde::Deserialize<'de>,
-                            {
-                                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>
-                            where
-                                T: _serde::Deserialize<'de>,
-                                U: _serde::Deserialize<'de>,
-                            {
-                                type Value = GenericEnum<T, U>;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result {
-                                    _serde::__private::Formatter::write_str(
-                                        __formatter,
-                                        "struct variant GenericEnum::Map",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    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);
-                                        }
-                                    } {
-                                        _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",
-                                                ),
-                                            );
-                                        }
-                                    };
-                                    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);
-                                        }
-                                    } {
-                                        _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",
-                                                ),
-                                            );
-                                        }
-                                    };
-                                    _serde::__private::Ok(GenericEnum::Map {
-                                        x: __field0,
-                                        y: __field1,
-                                    })
-                                }
-                                #[inline]
-                                fn visit_map<__A>(
-                                    self,
-                                    mut __map: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                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) {
-                                            _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"),
-                                                    );
-                                                }
-                                                __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<T>(&mut __map) {
-                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::__private::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            __Field::__field1 => {
-                                                if _serde::__private::Option::is_some(&__field1) {
-                                                    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) {
-                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::__private::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            _ => {
-                                                let _ = match _serde::de::MapAccess::next_value::<
-                                                    _serde::de::IgnoredAny,
-                                                >(&mut __map) {
-                                                    _serde::__private::Ok(__val) => __val,
-                                                    _serde::__private::Err(__err) => {
-                                                        return _serde::__private::Err(__err);
-                                                    }
-                                                };
-                                            }
-                                        }
-                                    }
-                                    let __field0 = match __field0 {
-                                        _serde::__private::Some(__field0) => __field0,
-                                        _serde::__private::None => {
-                                            match _serde::__private::de::missing_field("x") {
-                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::__private::Err(__err) => {
-                                                    return _serde::__private::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    let __field1 = match __field1 {
-                                        _serde::__private::Some(__field1) => __field1,
-                                        _serde::__private::None => {
-                                            match _serde::__private::de::missing_field("y") {
-                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::__private::Err(__err) => {
-                                                    return _serde::__private::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    _serde::__private::Ok(GenericEnum::Map {
-                                        x: __field0,
-                                        y: __field1,
-                                    })
-                                }
-                            }
-                            const FIELDS: &'static [&'static str] = &["x", "y"];
-                            _serde::de::VariantAccess::struct_variant(
-                                __variant,
-                                FIELDS,
-                                __Visitor {
-                                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::__private::PhantomData,
-                                },
-                            )
-                        }
-                    }
-                }
-            }
-            const VARIANTS: &'static [&'static str] = &["Unit", "NewType", "Seq", "Map"];
-            _serde::Deserializer::deserialize_enum(
-                __deserializer,
-                "GenericEnum",
-                VARIANTS,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/generic_enum.rs

@@ -1,9 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-pub enum GenericEnum<T, U> {
-    Unit,
-    NewType(T),
-    Seq(T, U),
-    Map { x: T, y: U },
-}

test_suite/tests/expand/generic_struct.expanded.rs

@@ -1,640 +0,0 @@
-use serde::{Deserialize, Serialize};
-pub struct GenericStruct<T> {
-    x: T,
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<T> _serde::Serialize for GenericStruct<T>
-    where
-        T: _serde::Serialize,
-    {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            let mut __serde_state = match _serde::Serializer::serialize_struct(
-                __serializer,
-                "GenericStruct",
-                false as usize + 1,
-            ) {
-                _serde::__private::Ok(__val) => __val,
-                _serde::__private::Err(__err) => {
-                    return _serde::__private::Err(__err);
-                }
-            };
-            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);
-                }
-            };
-            _serde::ser::SerializeStruct::end(__serde_state)
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __ignore,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "field identifier",
-                    )
-                }
-                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::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                marker: _serde::__private::PhantomData<GenericStruct<T>>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                type Value = GenericStruct<T>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "struct GenericStruct",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    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);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            return _serde::__private::Err(
-                                _serde::de::Error::invalid_length(
-                                    0usize,
-                                    &"struct GenericStruct with 1 element",
-                                ),
-                            );
-                        }
-                    };
-                    _serde::__private::Ok(GenericStruct { x: __field0 })
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __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) {
-                            _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"),
-                                    );
-                                }
-                                __field0 = _serde::__private::Some(
-                                    match _serde::de::MapAccess::next_value::<T>(&mut __map) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    let __field0 = match __field0 {
-                        _serde::__private::Some(__field0) => __field0,
-                        _serde::__private::None => {
-                            match _serde::__private::de::missing_field("x") {
-                                _serde::__private::Ok(__val) => __val,
-                                _serde::__private::Err(__err) => {
-                                    return _serde::__private::Err(__err);
-                                }
-                            }
-                        }
-                    };
-                    _serde::__private::Ok(GenericStruct { x: __field0 })
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["x"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "GenericStruct",
-                FIELDS,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<GenericStruct<T>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __ignore,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "field identifier",
-                    )
-                }
-                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::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de, 'place, T: 'place>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                place: &'place mut GenericStruct<T>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
-            for __Visitor<'de, 'place, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                type Value = ();
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "struct GenericStruct",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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",
-                            ),
-                        );
-                    }
-                    _serde::__private::Ok(())
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __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) {
-                            _serde::__private::Ok(__val) => __val,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
-                            }
-                        } {
-                        match __key {
-                            __Field::__field0 => {
-                                if __field0 {
-                                    return _serde::__private::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("x"),
-                                    );
-                                }
-                                match _serde::de::MapAccess::next_value_seed(
-                                    &mut __map,
-                                    _serde::__private::de::InPlaceSeed(&mut self.place.x),
-                                ) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                                __field0 = true;
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if !__field0 {
-                        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(())
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["x"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "GenericStruct",
-                FIELDS,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};
-pub struct GenericNewTypeStruct<T>(T);
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<T> _serde::Serialize for GenericNewTypeStruct<T>
-    where
-        T: _serde::Serialize,
-    {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            _serde::Serializer::serialize_newtype_struct(
-                __serializer,
-                "GenericNewTypeStruct",
-                &self.0,
-            )
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                marker: _serde::__private::PhantomData<GenericNewTypeStruct<T>>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                type Value = GenericNewTypeStruct<T>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericNewTypeStruct",
-                    )
-                }
-                #[inline]
-                fn visit_newtype_struct<__E>(
-                    self,
-                    __e: __E,
-                ) -> _serde::__private::Result<Self::Value, __E::Error>
-                where
-                    __E: _serde::Deserializer<'de>,
-                {
-                    let __field0: T = match <T as _serde::Deserialize>::deserialize(
-                        __e,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::__private::Ok(GenericNewTypeStruct(__field0))
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    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);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            return _serde::__private::Err(
-                                _serde::de::Error::invalid_length(
-                                    0usize,
-                                    &"tuple struct GenericNewTypeStruct with 1 element",
-                                ),
-                            );
-                        }
-                    };
-                    _serde::__private::Ok(GenericNewTypeStruct(__field0))
-                }
-            }
-            _serde::Deserializer::deserialize_newtype_struct(
-                __deserializer,
-                "GenericNewTypeStruct",
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<GenericNewTypeStruct<T>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, 'place, T: 'place>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                place: &'place mut GenericNewTypeStruct<T>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
-            for __Visitor<'de, 'place, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                type Value = ();
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericNewTypeStruct",
-                    )
-                }
-                #[inline]
-                fn visit_newtype_struct<__E>(
-                    self,
-                    __e: __E,
-                ) -> _serde::__private::Result<Self::Value, __E::Error>
-                where
-                    __E: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0)
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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",
-                            ),
-                        );
-                    }
-                    _serde::__private::Ok(())
-                }
-            }
-            _serde::Deserializer::deserialize_newtype_struct(
-                __deserializer,
-                "GenericNewTypeStruct",
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/generic_struct.rs

@@ -1,9 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-pub struct GenericStruct<T> {
-    x: T,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct GenericNewTypeStruct<T>(T);

test_suite/tests/expand/generic_tuple_struct.expanded.rs

@@ -1,187 +0,0 @@
-use serde::{Deserialize, Serialize};
-pub struct GenericTupleStruct<T, U>(T, U);
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-    where
-        T: _serde::Deserialize<'de>,
-        U: _serde::Deserialize<'de>,
-    {
-        fn deserialize<__D>(
-            __deserializer: __D,
-        ) -> _serde::__private::Result<Self, __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, T, U>
-            where
-                T: _serde::Deserialize<'de>,
-                U: _serde::Deserialize<'de>,
-            {
-                marker: _serde::__private::PhantomData<GenericTupleStruct<T, U>>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
-            where
-                T: _serde::Deserialize<'de>,
-                U: _serde::Deserialize<'de>,
-            {
-                type Value = GenericTupleStruct<T, U>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericTupleStruct",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    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);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            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) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            return _serde::__private::Err(
-                                _serde::de::Error::invalid_length(
-                                    1usize,
-                                    &"tuple struct GenericTupleStruct with 2 elements",
-                                ),
-                            );
-                        }
-                    };
-                    _serde::__private::Ok(GenericTupleStruct(__field0, __field1))
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "GenericTupleStruct",
-                2usize,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<GenericTupleStruct<T, U>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, 'place, T: 'place, U: 'place>
-            where
-                T: _serde::Deserialize<'de>,
-                U: _serde::Deserialize<'de>,
-            {
-                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>
-            where
-                T: _serde::Deserialize<'de>,
-                U: _serde::Deserialize<'de>,
-            {
-                type Value = ();
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericTupleStruct",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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.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(())
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "GenericTupleStruct",
-                2usize,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/generic_tuple_struct.rs

@@ -1,4 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Deserialize)]
-pub struct GenericTupleStruct<T, U>(T, U);

test_suite/tests/expand/lifetimes.expanded.rs

@@ -1,643 +0,0 @@
-use serde::{Deserialize, Serialize};
-enum Lifetimes<'a> {
-    LifetimeSeq(&'a i32),
-    NoLifetimeSeq(i32),
-    LifetimeMap { a: &'a i32 },
-    NoLifetimeMap { a: i32 },
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<'a> _serde::Serialize for Lifetimes<'a> {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            match *self {
-                Lifetimes::LifetimeSeq(ref __field0) => {
-                    _serde::Serializer::serialize_newtype_variant(
-                        __serializer,
-                        "Lifetimes",
-                        0u32,
-                        "LifetimeSeq",
-                        __field0,
-                    )
-                }
-                Lifetimes::NoLifetimeSeq(ref __field0) => {
-                    _serde::Serializer::serialize_newtype_variant(
-                        __serializer,
-                        "Lifetimes",
-                        1u32,
-                        "NoLifetimeSeq",
-                        __field0,
-                    )
-                }
-                Lifetimes::LifetimeMap { ref a } => {
-                    let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
-                        __serializer,
-                        "Lifetimes",
-                        2u32,
-                        "LifetimeMap",
-                        0 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-                Lifetimes::NoLifetimeMap { ref a } => {
-                    let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
-                        __serializer,
-                        "Lifetimes",
-                        3u32,
-                        "NoLifetimeMap",
-                        0 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-            }
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __field1,
-                __field2,
-                __field3,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "variant identifier",
-                    )
-                }
-                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),
-                        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",
-                                ),
-                            )
-                        }
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
-                        "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),
-                            )
-                        }
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
-                        b"NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
-                        b"LifetimeMap" => _serde::__private::Ok(__Field::__field2),
-                        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),
-                            )
-                        }
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de, 'a> {
-                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            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::Formatter::write_str(
-                        __formatter,
-                        "enum Lifetimes",
-                    )
-                }
-                fn visit_enum<__A>(
-                    self,
-                    __data: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::EnumAccess<'de>,
-                {
-                    match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            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::__field2, __variant) => {
-                            #[allow(non_camel_case_types)]
-                            enum __Field {
-                                __field0,
-                                __ignore,
-                            }
-                            struct __FieldVisitor;
-                            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                                type Value = __Field;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result {
-                                    _serde::__private::Formatter::write_str(
-                                        __formatter,
-                                        "field identifier",
-                                    )
-                                }
-                                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::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_str<__E>(
-                                    self,
-                                    __value: &str,
-                                ) -> _serde::__private::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        "a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_bytes<__E>(
-                                    self,
-                                    __value: &[u8],
-                                ) -> _serde::__private::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        b"a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                            }
-                            impl<'de> _serde::Deserialize<'de> for __Field {
-                                #[inline]
-                                fn deserialize<__D>(
-                                    __deserializer: __D,
-                                ) -> _serde::__private::Result<Self, __D::Error>
-                                where
-                                    __D: _serde::Deserializer<'de>,
-                                {
-                                    _serde::Deserializer::deserialize_identifier(
-                                        __deserializer,
-                                        __FieldVisitor,
-                                    )
-                                }
-                            }
-                            struct __Visitor<'de, 'a> {
-                                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::__private::PhantomData<&'de ()>,
-                            }
-                            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::Formatter::write_str(
-                                        __formatter,
-                                        "struct variant Lifetimes::LifetimeMap",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                                        &'a i32,
-                                    >(&mut __seq) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    } {
-                                        _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",
-                                                ),
-                                            );
-                                        }
-                                    };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
-                                        a: __field0,
-                                    })
-                                }
-                                #[inline]
-                                fn visit_map<__A>(
-                                    self,
-                                    mut __map: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                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) {
-                                            _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"),
-                                                    );
-                                                }
-                                                __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<
-                                                        &'a i32,
-                                                    >(&mut __map) {
-                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::__private::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            _ => {
-                                                let _ = match _serde::de::MapAccess::next_value::<
-                                                    _serde::de::IgnoredAny,
-                                                >(&mut __map) {
-                                                    _serde::__private::Ok(__val) => __val,
-                                                    _serde::__private::Err(__err) => {
-                                                        return _serde::__private::Err(__err);
-                                                    }
-                                                };
-                                            }
-                                        }
-                                    }
-                                    let __field0 = match __field0 {
-                                        _serde::__private::Some(__field0) => __field0,
-                                        _serde::__private::None => {
-                                            match _serde::__private::de::missing_field("a") {
-                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::__private::Err(__err) => {
-                                                    return _serde::__private::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
-                                        a: __field0,
-                                    })
-                                }
-                            }
-                            const FIELDS: &'static [&'static str] = &["a"];
-                            _serde::de::VariantAccess::struct_variant(
-                                __variant,
-                                FIELDS,
-                                __Visitor {
-                                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::__private::PhantomData,
-                                },
-                            )
-                        }
-                        (__Field::__field3, __variant) => {
-                            #[allow(non_camel_case_types)]
-                            enum __Field {
-                                __field0,
-                                __ignore,
-                            }
-                            struct __FieldVisitor;
-                            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                                type Value = __Field;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result {
-                                    _serde::__private::Formatter::write_str(
-                                        __formatter,
-                                        "field identifier",
-                                    )
-                                }
-                                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::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_str<__E>(
-                                    self,
-                                    __value: &str,
-                                ) -> _serde::__private::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        "a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_bytes<__E>(
-                                    self,
-                                    __value: &[u8],
-                                ) -> _serde::__private::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        b"a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::__private::Ok(__Field::__ignore),
-                                    }
-                                }
-                            }
-                            impl<'de> _serde::Deserialize<'de> for __Field {
-                                #[inline]
-                                fn deserialize<__D>(
-                                    __deserializer: __D,
-                                ) -> _serde::__private::Result<Self, __D::Error>
-                                where
-                                    __D: _serde::Deserializer<'de>,
-                                {
-                                    _serde::Deserializer::deserialize_identifier(
-                                        __deserializer,
-                                        __FieldVisitor,
-                                    )
-                                }
-                            }
-                            struct __Visitor<'de, 'a> {
-                                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::__private::PhantomData<&'de ()>,
-                            }
-                            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::Formatter::write_str(
-                                        __formatter,
-                                        "struct variant Lifetimes::NoLifetimeMap",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                                        i32,
-                                    >(&mut __seq) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    } {
-                                        _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",
-                                                ),
-                                            );
-                                        }
-                                    };
-                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap {
-                                        a: __field0,
-                                    })
-                                }
-                                #[inline]
-                                fn visit_map<__A>(
-                                    self,
-                                    mut __map: __A,
-                                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                                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) {
-                                            _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"),
-                                                    );
-                                                }
-                                                __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i32>(&mut __map) {
-                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::__private::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            _ => {
-                                                let _ = match _serde::de::MapAccess::next_value::<
-                                                    _serde::de::IgnoredAny,
-                                                >(&mut __map) {
-                                                    _serde::__private::Ok(__val) => __val,
-                                                    _serde::__private::Err(__err) => {
-                                                        return _serde::__private::Err(__err);
-                                                    }
-                                                };
-                                            }
-                                        }
-                                    }
-                                    let __field0 = match __field0 {
-                                        _serde::__private::Some(__field0) => __field0,
-                                        _serde::__private::None => {
-                                            match _serde::__private::de::missing_field("a") {
-                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::__private::Err(__err) => {
-                                                    return _serde::__private::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap {
-                                        a: __field0,
-                                    })
-                                }
-                            }
-                            const FIELDS: &'static [&'static str] = &["a"];
-                            _serde::de::VariantAccess::struct_variant(
-                                __variant,
-                                FIELDS,
-                                __Visitor {
-                                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::__private::PhantomData,
-                                },
-                            )
-                        }
-                    }
-                }
-            }
-            const VARIANTS: &'static [&'static str] = &[
-                "LifetimeSeq",
-                "NoLifetimeSeq",
-                "LifetimeMap",
-                "NoLifetimeMap",
-            ];
-            _serde::Deserializer::deserialize_enum(
-                __deserializer,
-                "Lifetimes",
-                VARIANTS,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/lifetimes.rs

@@ -1,9 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-enum Lifetimes<'a> {
-    LifetimeSeq(&'a i32),
-    NoLifetimeSeq(i32),
-    LifetimeMap { a: &'a i32 },
-    NoLifetimeMap { a: i32 },
-}

test_suite/tests/expand/named_map.expanded.rs

@@ -1,686 +0,0 @@
-use serde::{Deserialize, Serialize};
-struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
-    a: &'a A,
-    b: &'b mut B,
-    c: C,
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-    where
-        A: _serde::Serialize,
-        B: _serde::Serialize,
-        C: _serde::Serialize,
-    {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            let mut __serde_state = match _serde::Serializer::serialize_struct(
-                __serializer,
-                "SerNamedMap",
-                false as usize + 1 + 1 + 1,
-            ) {
-                _serde::__private::Ok(__val) => __val,
-                _serde::__private::Err(__err) => {
-                    return _serde::__private::Err(__err);
-                }
-            };
-            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,
-            ) {
-                _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,
-            ) {
-                _serde::__private::Ok(__val) => __val,
-                _serde::__private::Err(__err) => {
-                    return _serde::__private::Err(__err);
-                }
-            };
-            _serde::ser::SerializeStruct::end(__serde_state)
-        }
-    }
-};
-struct DeNamedMap<A, B, C> {
-    a: A,
-    b: B,
-    c: C,
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-    where
-        A: _serde::Deserialize<'de>,
-        B: _serde::Deserialize<'de>,
-        C: _serde::Deserialize<'de>,
-    {
-        fn deserialize<__D>(
-            __deserializer: __D,
-        ) -> _serde::__private::Result<Self, __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __field1,
-                __field2,
-                __ignore,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "field identifier",
-                    )
-                }
-                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),
-                        1u64 => _serde::__private::Ok(__Field::__field1),
-                        2u64 => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "a" => _serde::__private::Ok(__Field::__field0),
-                        "b" => _serde::__private::Ok(__Field::__field1),
-                        "c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"a" => _serde::__private::Ok(__Field::__field0),
-                        b"b" => _serde::__private::Ok(__Field::__field1),
-                        b"c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de, A, B, C>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                marker: _serde::__private::PhantomData<DeNamedMap<A, B, C>>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                type Value = DeNamedMap<A, B, C>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "struct DeNamedMap",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    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);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            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) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            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) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            return _serde::__private::Err(
-                                _serde::de::Error::invalid_length(
-                                    2usize,
-                                    &"struct DeNamedMap with 3 elements",
-                                ),
-                            );
-                        }
-                    };
-                    _serde::__private::Ok(DeNamedMap {
-                        a: __field0,
-                        b: __field1,
-                        c: __field2,
-                    })
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    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) {
-                            _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"),
-                                    );
-                                }
-                                __field0 = _serde::__private::Some(
-                                    match _serde::de::MapAccess::next_value::<A>(&mut __map) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            __Field::__field1 => {
-                                if _serde::__private::Option::is_some(&__field1) {
-                                    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) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            __Field::__field2 => {
-                                if _serde::__private::Option::is_some(&__field2) {
-                                    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) {
-                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::__private::Err(__err) => {
-                                            return _serde::__private::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    let __field0 = match __field0 {
-                        _serde::__private::Some(__field0) => __field0,
-                        _serde::__private::None => {
-                            match _serde::__private::de::missing_field("a") {
-                                _serde::__private::Ok(__val) => __val,
-                                _serde::__private::Err(__err) => {
-                                    return _serde::__private::Err(__err);
-                                }
-                            }
-                        }
-                    };
-                    let __field1 = match __field1 {
-                        _serde::__private::Some(__field1) => __field1,
-                        _serde::__private::None => {
-                            match _serde::__private::de::missing_field("b") {
-                                _serde::__private::Ok(__val) => __val,
-                                _serde::__private::Err(__err) => {
-                                    return _serde::__private::Err(__err);
-                                }
-                            }
-                        }
-                    };
-                    let __field2 = match __field2 {
-                        _serde::__private::Some(__field2) => __field2,
-                        _serde::__private::None => {
-                            match _serde::__private::de::missing_field("c") {
-                                _serde::__private::Ok(__val) => __val,
-                                _serde::__private::Err(__err) => {
-                                    return _serde::__private::Err(__err);
-                                }
-                            }
-                        }
-                    };
-                    _serde::__private::Ok(DeNamedMap {
-                        a: __field0,
-                        b: __field1,
-                        c: __field2,
-                    })
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["a", "b", "c"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DeNamedMap",
-                FIELDS,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<DeNamedMap<A, B, C>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {
-                __field0,
-                __field1,
-                __field2,
-                __ignore,
-            }
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "field identifier",
-                    )
-                }
-                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),
-                        1u64 => _serde::__private::Ok(__Field::__field1),
-                        2u64 => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "a" => _serde::__private::Ok(__Field::__field0),
-                        "b" => _serde::__private::Ok(__Field::__field1),
-                        "c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"a" => _serde::__private::Ok(__Field::__field0),
-                        b"b" => _serde::__private::Ok(__Field::__field1),
-                        b"c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::__private::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                place: &'place mut DeNamedMap<A, B, C>,
-                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>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                type Value = ();
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "struct DeNamedMap",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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.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",
-                            ),
-                        );
-                    }
-                    _serde::__private::Ok(())
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    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) {
-                            _serde::__private::Ok(__val) => __val,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
-                            }
-                        } {
-                        match __key {
-                            __Field::__field0 => {
-                                if __field0 {
-                                    return _serde::__private::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
-                                    );
-                                }
-                                match _serde::de::MapAccess::next_value_seed(
-                                    &mut __map,
-                                    _serde::__private::de::InPlaceSeed(&mut self.place.a),
-                                ) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                                __field0 = true;
-                            }
-                            __Field::__field1 => {
-                                if __field1 {
-                                    return _serde::__private::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("b"),
-                                    );
-                                }
-                                match _serde::de::MapAccess::next_value_seed(
-                                    &mut __map,
-                                    _serde::__private::de::InPlaceSeed(&mut self.place.b),
-                                ) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                                __field1 = true;
-                            }
-                            __Field::__field2 => {
-                                if __field2 {
-                                    return _serde::__private::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("c"),
-                                    );
-                                }
-                                match _serde::de::MapAccess::next_value_seed(
-                                    &mut __map,
-                                    _serde::__private::de::InPlaceSeed(&mut self.place.c),
-                                ) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                                __field2 = true;
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map) {
-                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::__private::Err(__err) => {
-                                        return _serde::__private::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if !__field0 {
-                        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") {
-                            _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") {
-                            _serde::__private::Ok(__val) => __val,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
-                            }
-                        };
-                    }
-                    _serde::__private::Ok(())
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["a", "b", "c"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DeNamedMap",
-                FIELDS,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/named_map.rs

@@ -1,15 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize)]
-struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
-    a: &'a A,
-    b: &'b mut B,
-    c: C,
-}
-
-#[derive(Deserialize)]
-struct DeNamedMap<A, B, C> {
-    a: A,
-    b: B,
-    c: C,
-}

test_suite/tests/expand/named_tuple.expanded.rs

@@ -1,288 +0,0 @@
-use serde::{Deserialize, Serialize};
-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(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>
-    where
-        A: _serde::Serialize,
-        B: _serde::Serialize,
-        C: _serde::Serialize,
-    {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            let mut __serde_state = match _serde::Serializer::serialize_tuple_struct(
-                __serializer,
-                "SerNamedTuple",
-                0 + 1 + 1 + 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.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,
-            ) {
-                _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,
-            ) {
-                _serde::__private::Ok(__val) => __val,
-                _serde::__private::Err(__err) => {
-                    return _serde::__private::Err(__err);
-                }
-            };
-            _serde::ser::SerializeTupleStruct::end(__serde_state)
-        }
-    }
-};
-struct DeNamedTuple<A, B, C>(A, B, C);
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-    where
-        A: _serde::Deserialize<'de>,
-        B: _serde::Deserialize<'de>,
-        C: _serde::Deserialize<'de>,
-    {
-        fn deserialize<__D>(
-            __deserializer: __D,
-        ) -> _serde::__private::Result<Self, __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, A, B, C>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                marker: _serde::__private::PhantomData<DeNamedTuple<A, B, C>>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                type Value = DeNamedTuple<A, B, C>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "tuple struct DeNamedTuple",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    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);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            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) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            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) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    } {
-                        _serde::__private::Some(__value) => __value,
-                        _serde::__private::None => {
-                            return _serde::__private::Err(
-                                _serde::de::Error::invalid_length(
-                                    2usize,
-                                    &"tuple struct DeNamedTuple with 3 elements",
-                                ),
-                            );
-                        }
-                    };
-                    _serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "DeNamedTuple",
-                3usize,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<DeNamedTuple<A, B, C>>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                place: &'place mut DeNamedTuple<A, B, C>,
-                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>
-            where
-                A: _serde::Deserialize<'de>,
-                B: _serde::Deserialize<'de>,
-                C: _serde::Deserialize<'de>,
-            {
-                type Value = ();
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "tuple struct DeNamedTuple",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                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.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",
-                            ),
-                        );
-                    }
-                    _serde::__private::Ok(())
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "DeNamedTuple",
-                3usize,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/named_tuple.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize)]
-struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
-
-#[derive(Deserialize)]
-struct DeNamedTuple<A, B, C>(A, B, C);

test_suite/tests/expand/named_unit.expanded.rs

@@ -1,61 +0,0 @@
-use serde::{Deserialize, Serialize};
-struct NamedUnit;
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl _serde::Serialize for NamedUnit {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            _serde::Serializer::serialize_unit_struct(__serializer, "NamedUnit")
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor;
-            impl<'de> _serde::de::Visitor<'de> for __Visitor {
-                type Value = NamedUnit;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "unit struct NamedUnit",
-                    )
-                }
-                #[inline]
-                fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    _serde::__private::Ok(NamedUnit)
-                }
-            }
-            _serde::Deserializer::deserialize_unit_struct(
-                __deserializer,
-                "NamedUnit",
-                __Visitor,
-            )
-        }
-    }
-};

test_suite/tests/expand/named_unit.rs

@@ -1,4 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-struct NamedUnit;

test_suite/tests/expand/ser_enum.expanded.rs

@@ -1,270 +0,0 @@
-use serde::Serialize;
-enum SerEnum<'a, B: 'a, C: 'a, D>
-where
-    D: 'a,
-{
-    Unit,
-    Seq(i8, B, &'a C, &'a mut D),
-    Map { a: i8, b: B, c: &'a C, d: &'a mut D },
-    _Unit2,
-    _Seq2(i8, B, &'a C, &'a mut D),
-    _Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
-}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-    where
-        D: 'a,
-        B: _serde::Serialize,
-        C: _serde::Serialize,
-        D: _serde::Serialize,
-    {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            match *self {
-                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,
-                        "SerEnum",
-                        1u32,
-                        "Seq",
-                        0 + 1 + 1 + 1 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field0,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field2,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field3,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeTupleVariant::end(__serde_state)
-                }
-                SerEnum::Map { ref a, ref b, ref c, ref d } => {
-                    let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
-                        __serializer,
-                        "SerEnum",
-                        2u32,
-                        "Map",
-                        0 + 1 + 1 + 1 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "b",
-                        b,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "c",
-                        c,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "d",
-                        d,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _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,
-                ) => {
-                    let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
-                        __serializer,
-                        "SerEnum",
-                        4u32,
-                        "_Seq2",
-                        0 + 1 + 1 + 1 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field0,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field2,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field3,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeTupleVariant::end(__serde_state)
-                }
-                SerEnum::_Map2 { ref a, ref b, ref c, ref d } => {
-                    let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
-                        __serializer,
-                        "SerEnum",
-                        5u32,
-                        "_Map2",
-                        0 + 1 + 1 + 1 + 1,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "b",
-                        b,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "c",
-                        c,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "d",
-                        d,
-                    ) {
-                        _serde::__private::Ok(__val) => __val,
-                        _serde::__private::Err(__err) => {
-                            return _serde::__private::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-            }
-        }
-    }
-};

test_suite/tests/expand/ser_enum.rs

@@ -1,16 +0,0 @@
-use serde::Serialize;
-
-#[derive(Serialize)]
-enum SerEnum<'a, B: 'a, C: 'a, D>
-where
-    D: 'a,
-{
-    Unit,
-    Seq(i8, B, &'a C, &'a mut D),
-    Map { a: i8, b: B, c: &'a C, d: &'a mut D },
-
-    // Make sure we can support more than one variant.
-    _Unit2,
-    _Seq2(i8, B, &'a C, &'a mut D),
-    _Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
-}

test_suite/tests/expand/void.expanded.rs

@@ -1,149 +0,0 @@
-use serde::{Deserialize, Serialize};
-enum Void {}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(unused_extern_crates, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl _serde::Serialize for Void {
-        fn serialize<__S>(
-            &self,
-            __serializer: __S,
-        ) -> _serde::__private::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            match *self {}
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[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>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            #[allow(non_camel_case_types)]
-            enum __Field {}
-            struct __FieldVisitor;
-            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-                type Value = __Field;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(
-                        __formatter,
-                        "variant identifier",
-                    )
-                }
-                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",
-                                ),
-                            )
-                        }
-                    }
-                }
-                fn visit_str<__E>(
-                    self,
-                    __value: &str,
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        _ => {
-                            _serde::__private::Err(
-                                _serde::de::Error::unknown_variant(__value, VARIANTS),
-                            )
-                        }
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::__private::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        _ => {
-                            let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(
-                                _serde::de::Error::unknown_variant(__value, VARIANTS),
-                            )
-                        }
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(
-                    __deserializer: __D,
-                ) -> _serde::__private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(
-                        __deserializer,
-                        __FieldVisitor,
-                    )
-                }
-            }
-            struct __Visitor<'de> {
-                marker: _serde::__private::PhantomData<Void>,
-                lifetime: _serde::__private::PhantomData<&'de ()>,
-            }
-            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
-                type Value = Void;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "enum Void")
-                }
-                fn visit_enum<__A>(
-                    self,
-                    __data: __A,
-                ) -> _serde::__private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::EnumAccess<'de>,
-                {
-                    _serde::__private::Result::map(
-                        _serde::de::EnumAccess::variant::<__Field>(__data),
-                        |(__impossible, _)| match __impossible {},
-                    )
-                }
-            }
-            const VARIANTS: &'static [&'static str] = &[];
-            _serde::Deserializer::deserialize_enum(
-                __deserializer,
-                "Void",
-                VARIANTS,
-                __Visitor {
-                    marker: _serde::__private::PhantomData::<Void>,
-                    lifetime: _serde::__private::PhantomData,
-                },
-            )
-        }
-    }
-};

test_suite/tests/expand/void.rs

@@ -1,4 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-enum Void {}

test_suite/tests/expandtest.rs

@@ -1,9 +0,0 @@
-#[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() {
-    macrotest::expand("tests/expand/*.rs");
-}

test_suite/tests/regression.rs

@@ -0,0 +1,3 @@
+mod regression {
+    automod::dir!("tests/regression");
+}

test_suite/tests/regression/issue2371.rs

@@ -0,0 +1,43 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Nested;
+
+#[derive(Deserialize)]
+pub enum ExternallyTagged {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "tag")]
+pub enum InternallyTagged {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "tag", content = "content")]
+pub enum AdjacentlyTagged {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum UntaggedWorkaround {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}

test_suite/tests/regression/issue2409.rs

@@ -0,0 +1,11 @@
+use serde::Deserialize;
+
+macro_rules! bug {
+    ($serde_path:literal) => {
+        #[derive(Deserialize)]
+        #[serde(crate = $serde_path)]
+        pub struct Struct;
+    };
+}
+
+bug!("serde");

test_suite/tests/regression/issue2415.rs

@@ -0,0 +1,5 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+#[serde()]
+pub struct S;

test_suite/tests/test_annotations.rs

@@ -6,7 +6,8 @@
     clippy::nonstandard_macro_braces,
     clippy::too_many_lines,
     clippy::trivially_copy_pass_by_ref,
-    clippy::type_repetition_in_bounds
+    clippy::type_repetition_in_bounds,
+    clippy::uninlined_format_args,
 )]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
@@ -641,7 +642,7 @@ fn test_unknown_field_rename_struct() {
             Token::Str("a4"),
             Token::I32(3),
         ],
-        "unknown field `a4`, expected one of `a1`, `a2`, `a6`",
+        "unknown field `a4`, expected one of `a1`, `a3`, `a2`, `a5`, `a6`",
     );
 }
 
@@ -779,7 +780,7 @@ fn test_rename_enum() {
             Token::StructVariant {
                 name: "AliasEnum",
                 variant: "sailor_moon",
-                len: 3,
+                len: 5,
             },
             Token::Str("a"),
             Token::I8(0),
@@ -797,7 +798,7 @@ fn test_rename_enum() {
             Token::StructVariant {
                 name: "AliasEnum",
                 variant: "usagi_tsukino",
-                len: 3,
+                len: 5,
             },
             Token::Str("a"),
             Token::I8(0),
@@ -826,7 +827,7 @@ fn test_unknown_field_rename_enum() {
             Token::StructVariant {
                 name: "AliasEnum",
                 variant: "usagi_tsukino",
-                len: 3,
+                len: 5,
             },
             Token::Str("a"),
             Token::I8(0),
@@ -835,7 +836,7 @@ fn test_unknown_field_rename_enum() {
             Token::Str("d"),
             Token::I8(2),
         ],
-        "unknown field `d`, expected one of `a`, `b`, `f`",
+        "unknown field `d`, expected one of `a`, `c`, `b`, `e`, `f`",
     );
 }
 
@@ -1235,7 +1236,7 @@ fn serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> Result<S:
 where
     S: Serializer,
 {
-    serializer.serialize_str(format!("{};{:?}", f1, f2).as_str())
+    serializer.collect_str(&format_args!("{};{:?}", f1, f2))
 }
 
 fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
@@ -1244,22 +1245,17 @@ where
 {
     let s = String::deserialize(deserializer)?;
     let mut pieces = s.split(';');
-    let f1 = match pieces.next() {
-        Some(x) => x,
-        None => return Err(de::Error::invalid_length(0, &"2")),
+    let Some(f1) = pieces.next() else {
+        return Err(de::Error::invalid_length(0, &"2"));
     };
-    let f2 = match pieces.next() {
-        Some(x) => x,
-        None => return Err(de::Error::invalid_length(1, &"2")),
+    let Some(f2) = pieces.next() else {
+        return Err(de::Error::invalid_length(1, &"2"));
     };
-    let f2 = match f2.parse() {
-        Ok(n) => n,
-        Err(_) => {
-            return Err(de::Error::invalid_value(
-                Unexpected::Str(f2),
-                &"an 8-bit signed integer",
-            ));
-        }
+    let Ok(f2) = f2.parse() else {
+        return Err(de::Error::invalid_value(
+            Unexpected::Str(f2),
+            &"an 8-bit signed integer",
+        ));
     };
     Ok((f1.into(), f2))
 }
@@ -1537,7 +1533,7 @@ fn test_invalid_length_enum() {
             Token::TupleVariant {
                 name: "InvalidLengthEnum",
                 variant: "B",
-                len: 3,
+                len: 2,
             },
             Token::I32(1),
             Token::TupleVariantEnd,
@@ -2302,6 +2298,72 @@ fn test_internally_tagged_enum_containing_flatten() {
     );
 }
 
+#[test]
+fn test_internally_tagged_enum_new_type_with_unit() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A(()),
+    }
+
+    assert_tokens(
+        &Data::A(()),
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_adjacently_tagged_enum_bytes() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t", content = "c")]
+    enum Data {
+        A { a: i32 },
+    }
+
+    let data = Data::A { a: 0 };
+
+    assert_tokens(
+        &data,
+        &[
+            Token::Struct {
+                name: "Data",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::Str("c"),
+            Token::Struct { name: "A", len: 1 },
+            Token::Str("a"),
+            Token::I32(0),
+            Token::StructEnd,
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Struct {
+                name: "Data",
+                len: 2,
+            },
+            Token::Bytes(b"t"),
+            Token::Str("A"),
+            Token::Bytes(b"c"),
+            Token::Struct { name: "A", len: 1 },
+            Token::Str("a"),
+            Token::I32(0),
+            Token::StructEnd,
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_adjacently_tagged_enum_containing_flatten() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2380,6 +2442,162 @@ fn test_untagged_enum_containing_flatten() {
     );
 }
 
+#[test]
+fn test_partially_untagged_enum() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    enum Exp {
+        Lambda(u32, Box<Exp>),
+        #[serde(untagged)]
+        App(Box<Exp>, Box<Exp>),
+        #[serde(untagged)]
+        Var(u32),
+    }
+    use Exp::*;
+
+    let data = Lambda(0, Box::new(App(Box::new(Var(0)), Box::new(Var(0)))));
+    assert_tokens(
+        &data,
+        &[
+            Token::TupleVariant {
+                name: "Exp",
+                variant: "Lambda",
+                len: 2,
+            },
+            Token::U32(0),
+            Token::Tuple { len: 2 },
+            Token::U32(0),
+            Token::U32(0),
+            Token::TupleEnd,
+            Token::TupleVariantEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_partially_untagged_enum_generic() {
+    trait Trait<T> {
+        type Assoc;
+        type Assoc2;
+    }
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    enum E<A, B, C>
+    where
+        A: Trait<C, Assoc2 = B>,
+    {
+        A(A::Assoc),
+        #[serde(untagged)]
+        B(A::Assoc2),
+    }
+
+    impl<T> Trait<T> for () {
+        type Assoc = T;
+        type Assoc2 = bool;
+    }
+
+    type MyE = E<(), bool, u32>;
+    use E::*;
+
+    assert_tokens::<MyE>(&B(true), &[Token::Bool(true)]);
+
+    assert_tokens::<MyE>(
+        &A(5),
+        &[
+            Token::NewtypeVariant {
+                name: "E",
+                variant: "A",
+            },
+            Token::U32(5),
+        ],
+    );
+}
+
+#[test]
+fn test_partially_untagged_enum_desugared() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    enum Test {
+        A(u32, u32),
+        B(u32),
+        #[serde(untagged)]
+        C(u32),
+        #[serde(untagged)]
+        D(u32, u32),
+    }
+    use Test::*;
+
+    mod desugared {
+        use super::*;
+        #[derive(Serialize, Deserialize, PartialEq, Debug)]
+        pub(super) enum Test {
+            A(u32, u32),
+            B(u32),
+        }
+    }
+    use desugared::Test as TestTagged;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(untagged)]
+    enum TestUntagged {
+        Tagged(TestTagged),
+        C(u32),
+        D(u32, u32),
+    }
+
+    impl From<Test> for TestUntagged {
+        fn from(test: Test) -> Self {
+            match test {
+                A(x, y) => TestUntagged::Tagged(TestTagged::A(x, y)),
+                B(x) => TestUntagged::Tagged(TestTagged::B(x)),
+                C(x) => TestUntagged::C(x),
+                D(x, y) => TestUntagged::D(x, y),
+            }
+        }
+    }
+
+    fn assert_tokens_desugared(value: Test, tokens: &[Token]) {
+        assert_tokens(&value, tokens);
+        let desugared: TestUntagged = value.into();
+        assert_tokens(&desugared, tokens);
+    }
+
+    assert_tokens_desugared(
+        A(0, 1),
+        &[
+            Token::TupleVariant {
+                name: "Test",
+                variant: "A",
+                len: 2,
+            },
+            Token::U32(0),
+            Token::U32(1),
+            Token::TupleVariantEnd,
+        ],
+    );
+
+    assert_tokens_desugared(
+        B(1),
+        &[
+            Token::NewtypeVariant {
+                name: "Test",
+                variant: "B",
+            },
+            Token::U32(1),
+        ],
+    );
+
+    assert_tokens_desugared(C(2), &[Token::U32(2)]);
+
+    assert_tokens_desugared(
+        D(3, 5),
+        &[
+            Token::Tuple { len: 2 },
+            Token::U32(3),
+            Token::U32(5),
+            Token::TupleEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_flatten_untagged_enum() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2643,6 +2861,68 @@ fn test_flatten_any_after_flatten_struct() {
     );
 }
 
+#[test]
+fn test_alias_in_flatten_context() {
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct Outer {
+        #[serde(flatten)]
+        a: AliasStruct,
+        b: i32,
+    }
+
+    assert_de_tokens(
+        &Outer {
+            a: AliasStruct {
+                a1: 1,
+                a2: 2,
+                a4: 4,
+            },
+            b: 7,
+        },
+        &[
+            Token::Struct {
+                name: "Outer",
+                len: 4,
+            },
+            Token::Str("a1"),
+            Token::I32(1),
+            Token::Str("a2"),
+            Token::I32(2),
+            Token::Str("a5"),
+            Token::I32(4),
+            Token::Str("b"),
+            Token::I32(7),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Outer {
+            a: AliasStruct {
+                a1: 1,
+                a2: 2,
+                a4: 4,
+            },
+            b: 7,
+        },
+        &[
+            Token::Struct {
+                name: "Outer",
+                len: 4,
+            },
+            Token::Str("a1"),
+            Token::I32(1),
+            Token::Str("a2"),
+            Token::I32(2),
+            Token::Str("a6"),
+            Token::I32(4),
+            Token::Str("b"),
+            Token::I32(7),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_expecting_message() {
     #[derive(Deserialize, PartialEq, Debug)]

test_suite/tests/test_borrow.rs

@@ -4,6 +4,8 @@
     clippy::used_underscore_binding
 )]
 
+use serde::de::value::{BorrowedStrDeserializer, MapDeserializer};
+use serde::de::IntoDeserializer;
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
 
@@ -130,20 +132,22 @@ fn test_cow() {
         borrowed: Cow<'b, str>,
     }
 
-    let tokens = &[
-        Token::Struct {
-            name: "Cows",
-            len: 2,
-        },
-        Token::Str("copied"),
-        Token::BorrowedStr("copied"),
-        Token::Str("borrowed"),
-        Token::BorrowedStr("borrowed"),
-        Token::StructEnd,
-    ];
+    struct BorrowedStr(&'static str);
 
-    let mut de = serde_test::Deserializer::new(tokens);
-    let cows = Cows::deserialize(&mut de).unwrap();
+    impl<'de> IntoDeserializer<'de> for BorrowedStr {
+        type Deserializer = BorrowedStrDeserializer<'de, serde::de::value::Error>;
+
+        fn into_deserializer(self) -> Self::Deserializer {
+            BorrowedStrDeserializer::new(self.0)
+        }
+    }
+
+    let de = MapDeserializer::new(IntoIterator::into_iter([
+        ("copied", BorrowedStr("copied")),
+        ("borrowed", BorrowedStr("borrowed")),
+    ]));
+
+    let cows = Cows::deserialize(de).unwrap();
 
     match cows.copied {
         Cow::Owned(ref s) if s == "copied" => {}

test_suite/tests/test_de.rs

@@ -5,6 +5,7 @@
     clippy::empty_enum,
     clippy::manual_assert,
     clippy::needless_pass_by_value,
+    clippy::uninlined_format_args,
     clippy::unreadable_literal
 )]
 #![cfg_attr(feature = "unstable", feature(never_type))]
@@ -13,6 +14,7 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::default::Default;
 use std::ffi::{CStr, CString, OsString};
 use std::fmt::Debug;
+use std::iter;
 use std::net;
 use std::num::{
     NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
@@ -32,7 +34,7 @@ use std::time::{Duration, UNIX_EPOCH};
 use std::sync::atomic::{AtomicI64, AtomicU64};
 
 use fnv::FnvHasher;
-use serde::de::DeserializeOwned;
+use serde::de::{DeserializeOwned, IntoDeserializer};
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, Configure, Token};
 
@@ -198,12 +200,11 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
     ]
     .into_iter()
     .chain(ignorable_tokens.iter().copied())
-    .chain(vec![Token::MapEnd].into_iter())
+    .chain(iter::once(Token::MapEnd))
     .collect();
 
-    let mut de = serde_test::Deserializer::new(&concated_tokens);
-    let base = IgnoreBase::deserialize(&mut de).unwrap();
-    assert_eq!(base, IgnoreBase { a: 1 });
+    let expected = IgnoreBase { a: 1 };
+    assert_de_tokens(&expected, &concated_tokens);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -2244,39 +2245,34 @@ fn test_cstr() {
 
 #[test]
 fn test_atomics() {
-    fn test<L, A, T>(load: L, val: T, token: Token)
+    fn test<L, A, T>(load: L, val: T)
     where
         L: Fn(&A, Ordering) -> T,
         A: DeserializeOwned,
-        T: PartialEq + Debug,
+        T: PartialEq + Debug + Copy + for<'de> IntoDeserializer<'de>,
     {
-        let tokens = &[token];
-        let mut de = serde_test::Deserializer::new(tokens);
-        match A::deserialize(&mut de) {
+        match A::deserialize(val.into_deserializer()) {
             Ok(v) => {
                 let loaded = load(&v, Ordering::Relaxed);
                 assert_eq!(val, loaded);
             }
             Err(e) => panic!("tokens failed to deserialize: {}", e),
-        };
-        if de.remaining() > 0 {
-            panic!("{} remaining tokens", de.remaining());
         }
     }
 
-    test(AtomicBool::load, true, Token::Bool(true));
-    test(AtomicI8::load, -127, Token::I8(-127i8));
-    test(AtomicI16::load, -510, Token::I16(-510i16));
-    test(AtomicI32::load, -131072, Token::I32(-131072i32));
-    test(AtomicIsize::load, -131072isize, Token::I32(-131072));
-    test(AtomicU8::load, 127, Token::U8(127u8));
-    test(AtomicU16::load, 510u16, Token::U16(510u16));
-    test(AtomicU32::load, 131072u32, Token::U32(131072u32));
-    test(AtomicUsize::load, 131072usize, Token::U32(131072));
+    test(AtomicBool::load, true);
+    test(AtomicI8::load, -127i8);
+    test(AtomicI16::load, -510i16);
+    test(AtomicI32::load, -131072i32);
+    test(AtomicIsize::load, -131072isize);
+    test(AtomicU8::load, 127u8);
+    test(AtomicU16::load, 510u16);
+    test(AtomicU32::load, 131072u32);
+    test(AtomicUsize::load, 131072usize);
 
     #[cfg(target_arch = "x86_64")]
     {
-        test(AtomicI64::load, -8589934592, Token::I64(-8589934592));
-        test(AtomicU64::load, 8589934592u64, Token::U64(8589934592));
+        test(AtomicI64::load, -8589934592i64);
+        test(AtomicU64::load, 8589934592u64);
     }
 }

test_suite/tests/test_gen.rs

@@ -7,6 +7,7 @@
     unknown_lints,
     mixed_script_confusables,
     clippy::derive_partial_eq_without_eq,
+    clippy::extra_unused_type_parameters,
     clippy::items_after_statements,
     clippy::missing_errors_doc,
     clippy::missing_panics_doc,
@@ -256,6 +257,16 @@ fn test_gen() {
     }
     assert::<VariantWithTraits2<X, X>>();
 
+    type PhantomDataAlias<T> = PhantomData<T>;
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(bound = "")]
+    struct PhantomDataWrapper<T> {
+        #[serde(default)]
+        field: PhantomDataAlias<T>,
+    }
+    assert::<PhantomDataWrapper<X>>();
+
     #[derive(Serialize, Deserialize)]
     struct CowStr<'a>(Cow<'a, str>);
     assert::<CowStr>();

test_suite/tests/test_macros.rs

@@ -1928,7 +1928,6 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
     );
 }
 
-#[deny(unaligned_references)]
 #[test]
 fn test_packed_struct_can_derive_serialize() {
     #[derive(Copy, Clone, Serialize)]

test_suite/tests/test_remote.rs

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

test_suite/tests/test_ser.rs

@@ -13,7 +13,7 @@ use std::sync::atomic::{
     AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
     AtomicUsize,
 };
-use std::sync::{Arc, Weak as ArcWeak};
+use std::sync::{Arc, Mutex, RwLock, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};
 
 #[cfg(unix)]
@@ -847,3 +847,39 @@ fn test_integer128() {
 
     assert_ser_tokens_error(&1u128, &[], "u128 is not supported");
 }
+
+#[test]
+fn test_refcell_dst() {
+    assert_ser_tokens(
+        &RefCell::new([true]) as &RefCell<[bool]>,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_mutex_dst() {
+    assert_ser_tokens(
+        &Mutex::new([true]) as &Mutex<[bool]>,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_rwlock_dst() {
+    assert_ser_tokens(
+        &RwLock::new([true]) as &RwLock<[bool]>,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    );
+}

test_suite/tests/test_serde_path.rs

@@ -1,4 +1,7 @@
-#![allow(clippy::type_repetition_in_bounds)]
+#![allow(
+    clippy::extra_unused_type_parameters,
+    clippy::type_repetition_in_bounds
+)]
 
 #[test]
 fn test_gen_custom_serde() {

test_suite/tests/ui/borrow/duplicate_variant.stderr

@@ -1,5 +1,5 @@
 error: duplicate serde attribute `borrow`
- --> tests/ui/borrow/duplicate_variant.rs:8:13
+ --> tests/ui/borrow/duplicate_variant.rs:9:15
   |
-8 |     #[serde(borrow)]
-  |             ^^^^^^
+9 |     S(#[serde(borrow)] Str<'a>),
+  |               ^^^^^^

test_suite/tests/ui/borrow/empty_lifetimes.rs

@@ -3,6 +3,8 @@ use serde_derive::Deserialize;
 #[derive(Deserialize)]
 struct Test<'a> {
     #[serde(borrow = "")]
+    r: &'a str,
+    #[serde(borrow = "  ")]
     s: &'a str,
 }
 

test_suite/tests/ui/borrow/empty_lifetimes.stderr

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

test_suite/tests/ui/enum-representation/partially_tagged_wrong_order.rs

@@ -0,0 +1,10 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+enum E {
+    #[serde(untagged)]
+    A(u8),
+    B(String),
+}
+
+fn main() {}

test_suite/tests/ui/enum-representation/partially_tagged_wrong_order.stderr

@@ -0,0 +1,5 @@
+error: all variants with the #[serde(untagged)] attribute must be placed at the end of the enum
+ --> tests/ui/enum-representation/partially_tagged_wrong_order.rs:6:5
+  |
+6 |     A(u8),
+  |     ^

test_suite/tests/ui/malformed/cut_off.stderr

@@ -1,4 +1,4 @@
-error: unexpected end of input, expected literal
+error: unexpected end of input, expected an expression
  --> tests/ui/malformed/cut_off.rs:4:17
   |
 4 | #[serde(rename =)]

test_suite/tests/ui/malformed/not_list.stderr

@@ -1,11 +1,11 @@
-error: expected #[serde(...)]
+error: expected attribute arguments in parentheses: #[serde(...)]
  --> tests/ui/malformed/not_list.rs:4:3
   |
 4 | #[serde]
   |   ^^^^^
 
-error: expected #[serde(...)]
- --> tests/ui/malformed/not_list.rs:5:3
+error: expected parentheses: #[serde(...)]
+ --> tests/ui/malformed/not_list.rs:5:9
   |
 5 | #[serde = "?"]
-  |   ^^^^^^^^^^^
+  |         ^

test_suite/tests/ui/malformed/trailing_expr.rs

@@ -0,0 +1,9 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+struct S {
+    #[serde(skip_serializing_if, x.is_empty())]
+    x: Vec<()>,
+}
+
+fn main() {}

test_suite/tests/ui/malformed/trailing_expr.stderr

@@ -0,0 +1,5 @@
+error: expected `=`
+ --> tests/ui/malformed/trailing_expr.rs:5:32
+  |
+5 |     #[serde(skip_serializing_if, x.is_empty())]
+  |                                ^

test_suite/tests/ui/remote/double_generic.rs

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

test_suite/tests/ui/remote/double_generic.stderr

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

test_suite/tests/ui/remote/wrong_getter.stderr

@@ -4,7 +4,7 @@ error[E0308]: mismatched types
 15 | #[derive(Serialize)]
    |          ^^^^^^^^^
    |          |
-   |          expected `u8`, found `u16`
+   |          expected `&u8`, found `&u16`
    |          arguments to this function are incorrect
    |
    = note: expected reference `&u8`

test_suite/tests/ui/remote/wrong_ser.stderr

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

test_suite/tests/ui/unexpected-literal/container.stderr

@@ -1,4 +1,4 @@
-error: unexpected literal in serde container attribute
+error: unexpected literal in nested attribute, expected ident
  --> tests/ui/unexpected-literal/container.rs:4:9
   |
 4 | #[serde("literal")]

test_suite/tests/ui/unexpected-literal/field.stderr

@@ -1,4 +1,4 @@
-error: unexpected literal in serde field attribute
+error: unexpected literal in nested attribute, expected ident
  --> tests/ui/unexpected-literal/field.rs:5:13
   |
 5 |     #[serde("literal")]

test_suite/tests/ui/unexpected-literal/variant.stderr

@@ -1,4 +1,4 @@
-error: unexpected literal in serde variant attribute
+error: unexpected literal in nested attribute, expected ident
  --> tests/ui/unexpected-literal/variant.rs:5:13
   |
 5 |     #[serde("literal")]