Release 1.0.156

Format with rustfmt 1.5.2-nightly
Merge pull request #2401 from dtolnay/docderive
2026-04-22 21:48:02 +00:00 · 2023-03-14 01:02:18 -07:00 · 2023-03-14 00:50:38 -07:00 · 2023-03-14 00:37:06 -07:00 · 2023-03-14 00:33:41 -07:00 · 2023-03-14 00:28:20 -07:00
203 changed files with 8086 additions and 8835 deletions
@@ -0,0 +1 @@
+test_suite/tests/expand/*.expanded.rs linguist-generated
@@ -5,43 +5,49 @@ on:
  pull_request:
  schedule: [cron: "40 1 * * *"]

+permissions:
+  contents: read
+
+env:
+  RUSTFLAGS: -Dwarnings
+
 jobs:
  test:
    name: Test suite
    runs-on: ubuntu-latest
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd test_suite && cargo test --features unstable

  windows:
    name: Test suite (windows)
    runs-on: windows-latest
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd test_suite && cargo test --features unstable -- --skip ui --exact

  stable:
-    name: Rust stable
+    name: Rust ${{matrix.rust}}
    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [stable, beta]
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
      - run: cd serde && cargo build --features rc
      - run: cd serde && cargo build --no-default-features
      - run: cd serde_test && cargo build
      - run: cd serde_test && cargo test --features serde/derive,serde/rc

-  beta:
-    name: Rust beta
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: dtolnay/rust-toolchain@beta
-      - run: cd serde && cargo build --features rc
-      - run: cd test_suite && cargo test
-
  nightly:
    name: Rust nightly ${{matrix.os == 'windows' && '(windows)' || ''}}
    runs-on: ${{matrix.os}}-latest
@@ -49,8 +55,9 @@ jobs:
      fail-fast: false
      matrix:
        os: [ubuntu, windows]
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd serde && cargo build
      - run: cd serde && cargo build --no-default-features
@@ -59,23 +66,10 @@ jobs:
      - run: cd serde && cargo test --features derive,rc,unstable
      - run: cd test_suite/no_std && cargo build
        if: matrix.os != 'windows'
-
-  msrv:
-    name: Rust 1.13.0
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - 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
+      - run: cd serde_derive && cargo check --tests
+        env:
+          RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
+        if: matrix.os != 'windows'

  build:
    name: Rust ${{matrix.rust}}
@@ -84,13 +78,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@v2
+      - 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}}
@@ -99,8 +96,9 @@ jobs:
      fail-fast: false
      matrix:
        rust: [1.27.0, 1.28.0]
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{matrix.rust}}
@@ -112,52 +110,58 @@ jobs:
  derive:
    name: Rust 1.31.0
    runs-on: ubuntu-latest
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@1.31.0
+      - run: cd serde && cargo check --no-default-features
+      - run: cd serde && cargo check
      - run: cd serde_derive && cargo check

  alloc:
    name: Rust 1.36.0
    runs-on: ubuntu-latest
+    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@1.36.0
      - run: cd serde && cargo build --no-default-features --features alloc

-  emscripten:
-    name: Emscripten
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - 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@v2
+      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@clippy
-        # The need for -Aredundant_field_names here is a Clippy bug.
-        # https://github.com/rust-lang/rust-clippy/issues/5356
-      - run: cd serde && cargo clippy --features rc,unstable -- -D clippy::all -A clippy::redundant_field_names
-      - run: cd serde_derive && cargo clippy -- -D clippy::all
-      - run: cd serde_test && cargo clippy -- -D clippy::all -A clippy::redundant_field_names
-      - run: cd test_suite && cargo clippy --tests --features unstable -- -D clippy::all -A clippy::redundant_field_names
-      - run: cd test_suite/no_std && cargo clippy -- -D clippy::all -A clippy::redundant_field_names
+      - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
+      - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+      - run: cd serde_derive_internals && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+      - run: cd serde_test && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+      - run: cd test_suite && cargo clippy --tests --features unstable -- -Dclippy::all -Dclippy::pedantic
+      - run: cd test_suite/no_std && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+
+  miri:
+    name: Miri
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@miri
+      - run: cd serde && cargo miri test --features derive,rc,unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+      - run: cd test_suite && cargo miri test --features unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+
+  outdated:
+    name: Outdated
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --workspace --exit-code 1
@@ -31,25 +31,19 @@ tests for you.

 ```sh
 # Test all the example code in Serde documentation
-cargo test
-```
-
-##### In the [`test_suite/deps`] directory
-
-```sh
-# This is a prerequisite for running the full test suite
-cargo clean && cargo update && cargo build
+cargo test --features derive
 ```

 ##### In the [`test_suite`] directory

 ```sh
 # Run the full test suite, including tests of unstable functionality
-cargo test --features unstable
+cargo +nightly test --features unstable
 ```

+Note that this test suite currently only supports running on a nightly compiler.
+
 [`serde`]: https://github.com/serde-rs/serde/tree/master/serde
-[`test_suite/deps`]: https://github.com/serde-rs/serde/tree/master/test_suite/deps
 [`test_suite`]: https://github.com/serde-rs/serde/tree/master/test_suite

 ## Conduct
@@ -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.
@@ -1,12 +1,12 @@
-# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
+# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![serde_derive: rustc 1.31+]][Rust 1.31]

-[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: rustc 1.19+]: https://img.shields.io/badge/serde-rustc_1.19+-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.19]: https://blog.rust-lang.org/2017/07/20/Rust-1.19.html
 [Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.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
@@ -77,17 +77,20 @@ fn main() {

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

-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
+[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
 [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
 [zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
 [stackoverflow]: https://stackoverflow.com/questions/tagged/rust
 [/r/rust]: https://www.reddit.com/r/rust
@@ -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
@@ -45,17 +45,20 @@ fn main() {

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

-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
+[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
 [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
 [zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
 [stackoverflow]: https://stackoverflow.com/questions/tagged/rust
 [/r/rust]: https://www.reddit.com/r/rust
@@ -0,0 +1 @@
+msrv = "1.13.0"
@@ -1,28 +1,33 @@
 [package]
 name = "serde"
-version = "1.0.117" # remember to update html_root_url and serde_derive dependency
+version = "1.0.156" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT OR Apache-2.0"
-description = "A generic serialization/deserialization framework"
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
-documentation = "https://docs.serde.rs/serde/"
-keywords = ["serde", "serialization", "no_std"]
-categories = ["encoding"]
-readme = "crates-io.md"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 build = "build.rs"
+categories = ["encoding", "no-std"]
+description = "A generic serialization/deserialization framework"
+documentation = "https://docs.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.117", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.156", 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"]


@@ -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,
@@ -17,84 +19,107 @@ fn main() {
    // std::collections::Bound was stabilized in Rust 1.17
    // but it was moved to core::ops later in Rust 1.26:
    // https://doc.rust-lang.org/core/ops/enum.Bound.html
-    if minor >= 26 {
-        println!("cargo:rustc-cfg=ops_bound");
-    } else if minor >= 17 && cfg!(feature = "std") {
-        println!("cargo:rustc-cfg=collections_bound");
+    if minor < 26 {
+        println!("cargo:rustc-cfg=no_ops_bound");
+        if minor < 17 {
+            println!("cargo:rustc-cfg=no_collections_bound");
+        }
    }

    // core::cmp::Reverse stabilized in Rust 1.19:
    // https://doc.rust-lang.org/stable/core/cmp/struct.Reverse.html
-    if minor >= 19 {
-        println!("cargo:rustc-cfg=core_reverse");
+    if minor < 19 {
+        println!("cargo:rustc-cfg=no_core_reverse");
    }

    // CString::into_boxed_c_str and PathBuf::into_boxed_path stabilized in Rust 1.20:
    // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
    // https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.into_boxed_path
-    if minor >= 20 {
-        println!("cargo:rustc-cfg=de_boxed_c_str");
-        println!("cargo:rustc-cfg=de_boxed_path");
+    if minor < 20 {
+        println!("cargo:rustc-cfg=no_de_boxed_c_str");
+        println!("cargo:rustc-cfg=no_de_boxed_path");
    }

    // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:
    // https://doc.rust-lang.org/std/rc/struct.Rc.html#impl-From<Box<T>>
    // https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-From<Box<T>>
-    if minor >= 21 {
-        println!("cargo:rustc-cfg=de_rc_dst");
+    if minor < 21 {
+        println!("cargo:rustc-cfg=no_de_rc_dst");
    }

    // Duration available in core since Rust 1.25:
    // https://blog.rust-lang.org/2018/03/29/Rust-1.25.html#library-stabilizations
-    if minor >= 25 {
-        println!("cargo:rustc-cfg=core_duration");
+    if minor < 25 {
+        println!("cargo:rustc-cfg=no_core_duration");
    }

    // 128-bit integers stabilized in Rust 1.26:
    // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
    //
-    // Disabled on Emscripten targets as Emscripten doesn't
-    // currently support integers larger than 64 bits.
-    if minor >= 26 && !emscripten {
-        println!("cargo:rustc-cfg=integer128");
+    // Disabled on Emscripten targets before Rust 1.40 since
+    // Emscripten did not support 128-bit integers until Rust 1.40
+    // (https://github.com/rust-lang/rust/pull/65251)
+    if minor < 26 || emscripten && minor < 40 {
+        println!("cargo:rustc-cfg=no_integer128");
    }

    // Inclusive ranges methods stabilized in Rust 1.27:
    // https://github.com/rust-lang/rust/pull/50758
-    if minor >= 27 {
-        println!("cargo:rustc-cfg=range_inclusive");
+    // Also Iterator::try_for_each:
+    // https://blog.rust-lang.org/2018/06/21/Rust-1.27.html#library-stabilizations
+    if minor < 27 {
+        println!("cargo:rustc-cfg=no_range_inclusive");
+        println!("cargo:rustc-cfg=no_iterator_try_fold");
    }

    // Non-zero integers stabilized in Rust 1.28:
    // https://blog.rust-lang.org/2018/08/02/Rust-1.28.html#library-stabilizations
-    if minor >= 28 {
-        println!("cargo:rustc-cfg=num_nonzero");
+    if minor < 28 {
+        println!("cargo:rustc-cfg=no_num_nonzero");
    }

-    // TryFrom, Atomic types, and non-zero signed integers stabilized in Rust 1.34:
+    // Current minimum supported version of serde_derive crate is Rust 1.31.
+    if minor < 31 {
+        println!("cargo:rustc-cfg=no_serde_derive");
+    }
+
+    // TryFrom, Atomic types, non-zero signed integers, and SystemTime::checked_add
+    // stabilized in Rust 1.34:
    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#library-stabilizations
-    if minor >= 34 {
-        println!("cargo:rustc-cfg=core_try_from");
-        println!("cargo:rustc-cfg=num_nonzero_signed");
+    if minor < 34 {
+        println!("cargo:rustc-cfg=no_core_try_from");
+        println!("cargo:rustc-cfg=no_num_nonzero_signed");
+        println!("cargo:rustc-cfg=no_systemtime_checked_add");
+        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 src/librustc_target/spec/*.rs.
+    // 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("mips64el")
+            || target.starts_with("riscv64");
        let has_atomic32 = has_atomic64 || emscripten;
-        if has_atomic64 {
-            println!("cargo:rustc-cfg=std_atomic64");
+        if minor < 34 || !has_atomic64 {
+            println!("cargo:rustc-cfg=no_std_atomic64");
        }
-        if has_atomic32 {
-            println!("cargo:rustc-cfg=std_atomic");
+        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");
+    }
 }

 fn rustc_minor_version() -> Option<u32> {
@@ -0,0 +1,30 @@
+use lib::fmt::{self, Write};
+use lib::str;
+
+pub(super) struct Buf<'a> {
+    bytes: &'a mut [u8],
+    offset: usize,
+}
+
+impl<'a> Buf<'a> {
+    pub fn new(bytes: &'a mut [u8]) -> Self {
+        Buf { bytes, offset: 0 }
+    }
+
+    pub fn as_str(&self) -> &str {
+        let slice = &self.bytes[..self.offset];
+        unsafe { str::from_utf8_unchecked(slice) }
+    }
+}
+
+impl<'a> Write for Buf<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        if self.offset + s.len() > self.bytes.len() {
+            Err(fmt::Error)
+        } else {
+            self.bytes[self.offset..self.offset + s.len()].copy_from_slice(s.as_bytes());
+            self.offset += s.len();
+            Ok(())
+        }
+    }
+}
@@ -1,260 +0,0 @@
-use lib::*;
-
-macro_rules! int_to_int {
-    ($dst:ident, $n:ident) => {
-        if $dst::min_value() as i64 <= $n as i64 && $n as i64 <= $dst::max_value() as i64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-macro_rules! int_to_uint {
-    ($dst:ident, $n:ident) => {
-        if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-macro_rules! uint_to {
-    ($dst:ident, $n:ident) => {
-        if $n as u64 <= $dst::max_value() as u64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-pub trait FromPrimitive: Sized {
-    fn from_i8(n: i8) -> Option<Self>;
-    fn from_i16(n: i16) -> Option<Self>;
-    fn from_i32(n: i32) -> Option<Self>;
-    fn from_i64(n: i64) -> Option<Self>;
-    fn from_u8(n: u8) -> Option<Self>;
-    fn from_u16(n: u16) -> Option<Self>;
-    fn from_u32(n: u32) -> Option<Self>;
-    fn from_u64(n: u64) -> Option<Self>;
-}
-
-macro_rules! impl_from_primitive_for_int {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                uint_to!($t, n)
-            }
-        }
-    };
-}
-
-macro_rules! impl_from_primitive_for_uint {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                uint_to!($t, n)
-            }
-        }
-    };
-}
-
-macro_rules! impl_from_primitive_for_float {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                Some(n as Self)
-            }
-        }
-    };
-}
-
-impl_from_primitive_for_int!(isize);
-impl_from_primitive_for_int!(i8);
-impl_from_primitive_for_int!(i16);
-impl_from_primitive_for_int!(i32);
-impl_from_primitive_for_int!(i64);
-impl_from_primitive_for_uint!(usize);
-impl_from_primitive_for_uint!(u8);
-impl_from_primitive_for_uint!(u16);
-impl_from_primitive_for_uint!(u32);
-impl_from_primitive_for_uint!(u64);
-impl_from_primitive_for_float!(f32);
-impl_from_primitive_for_float!(f64);
-
-serde_if_integer128! {
-    impl FromPrimitive for i128 {
-        #[inline]
-        fn from_i8(n: i8) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i16(n: i16) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i32(n: i32) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u8(n: u8) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u16(n: u16) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u32(n: u32) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Some(n as i128)
-        }
-    }
-
-    impl FromPrimitive for u128 {
-        #[inline]
-        fn from_i8(n: i8) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i16(n: i16) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i32(n: i32) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_u8(n: u8) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u16(n: u16) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u32(n: u32) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Some(n as u128)
-        }
-    }
-}
@@ -130,12 +130,28 @@ impl<'de> Visitor<'de> for IgnoredAny {
        Ok(IgnoredAny)
    }

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

+    serde_if_integer128! {
+        #[inline]
+        fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
+            let _ = x;
+            Ok(IgnoredAny)
+        }
+    }
+
    #[inline]
    fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
        let _ = x;
@@ -212,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()
    }
 }

@@ -30,7 +30,7 @@
 //! # The Deserializer trait
 //!
 //! [`Deserializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
+//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
 //!
 //! A partial list of well-maintained formats is given on the [Serde
 //! website][data formats].
@@ -104,7 +104,7 @@
 //! [`Deserialize`]: ../trait.Deserialize.html
 //! [`Deserializer`]: ../trait.Deserializer.html
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`bincode`]: https://github.com/servo/bincode
+//! [`postcard`]: https://github.com/jamesmunns/postcard
 //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
@@ -118,7 +118,8 @@ use lib::*;

 pub mod value;

-mod from_primitive;
+#[cfg(not(no_integer128))]
+mod format;
 mod ignored_any;
 mod impls;
 mod utf8;
@@ -393,7 +394,7 @@ pub enum Unexpected<'a> {
 }

 impl<'a> fmt::Display for Unexpected<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        use self::Unexpected::*;
        match *self {
            Bool(b) => write!(formatter, "boolean `{}`", b),
@@ -500,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
@@ -517,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
 ///
@@ -564,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(())
    }
 }
@@ -707,6 +707,11 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 ///             where
 ///                 A: SeqAccess<'de>,
 ///             {
+///                 // Decrease the number of reallocations if there are many elements
+///                 if let Some(size_hint) = seq.size_hint() {
+///                    self.0.reserve(size_hint);
+///                 }
+///
 ///                 // Visit each element in the inner array and push it onto
 ///                 // the existing vector.
 ///                 while let Some(elem) = seq.next_element()? {
@@ -856,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
@@ -868,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
@@ -878,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
@@ -909,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
@@ -1008,7 +1013,7 @@ pub trait Deserializer<'de>: Sized {
    /// `Deserializer`.
    ///
    /// If the `Visitor` would benefit from taking ownership of `String` data,
-    /// indiciate this to the `Deserializer` by using `deserialize_string`
+    /// indicate this to the `Deserializer` by using `deserialize_string`
    /// instead.
    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
@@ -1150,7 +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
@@ -1214,6 +1219,20 @@ pub trait Deserializer<'de>: Sized {
    fn is_human_readable(&self) -> bool {
        true
    }
+
+    // Not public API.
+    #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
+    #[doc(hidden)]
+    fn __deserialize_content<V>(
+        self,
+        _: ::actually_private::T,
+        visitor: V,
+    ) -> Result<::private::de::Content<'de>, Self::Error>
+    where
+        V: Visitor<'de, Value = ::private::de::Content<'de>>,
+    {
+        self.deserialize_any(visitor)
+    }
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -1353,8 +1372,10 @@ pub trait Visitor<'de>: Sized {
        where
            E: Error,
        {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("i128"), &self))
+            let mut buf = [0u8; 58];
+            let mut writer = format::Buf::new(&mut buf);
+            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
+            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
        }
    }

@@ -1413,8 +1434,10 @@ pub trait Visitor<'de>: Sized {
        where
            E: Error,
        {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("u128"), &self))
+            let mut buf = [0u8; 57];
+            let mut writer = format::Buf::new(&mut buf);
+            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
+            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
        }
    }

@@ -1536,7 +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`.
@@ -1715,7 +1738,7 @@ pub trait SeqAccess<'de> {
    }
 }

-impl<'de, 'a, A> SeqAccess<'de> for &'a mut A
+impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
 where
    A: SeqAccess<'de>,
 {
@@ -1868,7 +1891,7 @@ pub trait MapAccess<'de> {
    }
 }

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

 use self::private::{First, Second};
-use de::{self, Expected, IntoDeserializer, SeqAccess};
-use private::de::size_hint;
+use __private::size_hint;
+use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor};
 use ser;

 ////////////////////////////////////////////////////////////////////////////////
@@ -48,7 +48,7 @@ macro_rules! impl_copy_clone {

 /// A minimal representation of all possible errors that can occur using the
 /// `IntoDeserializer` trait.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub struct Error {
    err: ErrorImpl,
 }
@@ -93,16 +93,25 @@ impl ser::Error for Error {

 impl Display for Error {
    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str(&self.err)
    }

    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Serde deserialization error")
    }
 }

+impl Debug for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = formatter.debug_tuple("Error");
+        #[cfg(any(feature = "std", feature = "alloc"))]
+        debug.field(&self.err);
+        debug.finish()
+    }
+}
+
 #[cfg(feature = "std")]
 impl error::Error for Error {
    fn description(&self) -> &str {
@@ -119,20 +128,26 @@ where
    type Deserializer = UnitDeserializer<E>;

    fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer {
-            marker: PhantomData,
-        }
+        UnitDeserializer::new()
    }
 }

 /// A deserializer holding a `()`.
-#[derive(Debug)]
 pub struct UnitDeserializer<E> {
    marker: PhantomData<E>,
 }

 impl_copy_clone!(UnitDeserializer);

+impl<E> UnitDeserializer<E> {
+    #[allow(missing_docs)]
+    pub fn new() -> Self {
+        UnitDeserializer {
+            marker: PhantomData,
+        }
+    }
+}
+
 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
 where
    E: de::Error,
@@ -160,6 +175,12 @@ where
    }
 }

+impl<E> Debug for UnitDeserializer<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.debug_struct("UnitDeserializer").finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 /// A deserializer that cannot be instantiated.
@@ -208,7 +229,6 @@ macro_rules! primitive_deserializer {
    ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
        #[doc = "A deserializer holding"]
        #[doc = $doc]
-        #[derive(Debug)]
        pub struct $name<E> {
            value: $ty,
            marker: PhantomData<E>
@@ -223,8 +243,15 @@ macro_rules! primitive_deserializer {
            type Deserializer = $name<E>;

            fn into_deserializer(self) -> $name<E> {
+                $name::new(self)
+            }
+        }
+
+        impl<E> $name<E> {
+            #[allow(missing_docs)]
+            pub fn new(value: $ty) -> Self {
                $name {
-                    value: self,
+                    value: value,
                    marker: PhantomData,
                }
            }
@@ -249,6 +276,15 @@ macro_rules! primitive_deserializer {
                visitor.$method(self.value $($cast)*)
            }
        }
+
+        impl<E> Debug for $name<E> {
+            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter
+                    .debug_struct(stringify!($name))
+                    .field("value", &self.value)
+                    .finish()
+            }
+        }
    }
 }

@@ -272,7 +308,6 @@ serde_if_integer128! {
 }

 /// A deserializer holding a `u32`.
-#[derive(Debug)]
 pub struct U32Deserializer<E> {
    value: u32,
    marker: PhantomData<E>,
@@ -287,8 +322,15 @@ where
    type Deserializer = U32Deserializer<E>;

    fn into_deserializer(self) -> U32Deserializer<E> {
+        U32Deserializer::new(self)
+    }
+}
+
+impl<E> U32Deserializer<E> {
+    #[allow(missing_docs)]
+    pub fn new(value: u32) -> Self {
        U32Deserializer {
-            value: self,
+            value: value,
            marker: PhantomData,
        }
    }
@@ -343,10 +385,18 @@ where
    }
 }

+impl<E> Debug for U32Deserializer<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("U32Deserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 /// A deserializer holding a `&str`.
-#[derive(Debug)]
 pub struct StrDeserializer<'a, E> {
    value: &'a str,
    marker: PhantomData<E>,
@@ -361,8 +411,15 @@ where
    type Deserializer = StrDeserializer<'a, E>;

    fn into_deserializer(self) -> StrDeserializer<'a, E> {
+        StrDeserializer::new(self)
+    }
+}
+
+impl<'a, E> StrDeserializer<'a, E> {
+    #[allow(missing_docs)]
+    pub fn new(value: &'a str) -> Self {
        StrDeserializer {
-            value: self,
+            value: value,
            marker: PhantomData,
        }
    }
@@ -417,11 +474,19 @@ where
    }
 }

+impl<'a, E> Debug for StrDeserializer<'a, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("StrDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 /// A deserializer holding a `&str` with a lifetime tied to another
 /// deserializer.
-#[derive(Debug)]
 pub struct BorrowedStrDeserializer<'de, E> {
    value: &'de str,
    marker: PhantomData<E>,
@@ -488,11 +553,19 @@ where
    }
 }

+impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("BorrowedStrDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 /// A deserializer holding a `String`.
 #[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Debug)]
 pub struct StringDeserializer<E> {
    value: String,
    marker: PhantomData<E>,
@@ -516,8 +589,16 @@ where
    type Deserializer = StringDeserializer<E>;

    fn into_deserializer(self) -> StringDeserializer<E> {
+        StringDeserializer::new(self)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> StringDeserializer<E> {
+    #[allow(missing_docs)]
+    pub fn new(value: String) -> Self {
        StringDeserializer {
-            value: self,
+            value: value,
            marker: PhantomData,
        }
    }
@@ -559,7 +640,7 @@ where
 }

 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E>
+impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E>
 where
    E: de::Error,
 {
@@ -574,11 +655,20 @@ where
    }
 }

+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> Debug for StringDeserializer<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("StringDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 /// A deserializer holding a `Cow<str>`.
 #[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Debug)]
 pub struct CowStrDeserializer<'a, E> {
    value: Cow<'a, str>,
    marker: PhantomData<E>,
@@ -602,8 +692,16 @@ where
    type Deserializer = CowStrDeserializer<'a, E>;

    fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
+        CowStrDeserializer::new(self)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> CowStrDeserializer<'a, E> {
+    #[allow(missing_docs)]
+    pub fn new(value: Cow<'a, str>) -> Self {
        CowStrDeserializer {
-            value: self,
+            value: value,
            marker: PhantomData,
        }
    }
@@ -663,29 +761,48 @@ where
    }
 }

+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> Debug for CowStrDeserializer<'a, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("CowStrDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

-/// A deserializer holding a `&[u8]` with a lifetime tied to another
-/// deserializer.
-#[derive(Debug)]
-pub struct BorrowedBytesDeserializer<'de, E> {
-    value: &'de [u8],
+/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
+pub struct BytesDeserializer<'a, E> {
+    value: &'a [u8],
    marker: PhantomData<E>,
 }

-impl_copy_clone!(BorrowedBytesDeserializer<'de>);
-
-impl<'de, E> BorrowedBytesDeserializer<'de, E> {
-    /// Create a new borrowed deserializer from the given byte slice.
-    pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> {
-        BorrowedBytesDeserializer {
+impl<'a, E> BytesDeserializer<'a, E> {
+    /// Create a new deserializer from the given bytes.
+    pub fn new(value: &'a [u8]) -> Self {
+        BytesDeserializer {
            value: value,
            marker: PhantomData,
        }
    }
 }

-impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
+impl_copy_clone!(BytesDeserializer<'a>);
+
+impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8]
+where
+    E: de::Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+
+    fn into_deserializer(self) -> BytesDeserializer<'a, E> {
+        BytesDeserializer::new(self)
+    }
+}
+
+impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
 where
    E: de::Error,
 {
@@ -693,7 +810,55 @@ where

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
-        V: de::Visitor<'de>,
+        V: Visitor<'de>,
+    {
+        visitor.visit_bytes(self.value)
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+impl<'a, E> Debug for BytesDeserializer<'a, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("BytesDeserializer")
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
+/// A deserializer holding a `&[u8]` with a lifetime tied to another
+/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
+pub struct BorrowedBytesDeserializer<'de, E> {
+    value: &'de [u8],
+    marker: PhantomData<E>,
+}
+
+impl<'de, E> BorrowedBytesDeserializer<'de, E> {
+    /// Create a new borrowed deserializer from the given borrowed bytes.
+    pub fn new(value: &'de [u8]) -> Self {
+        BorrowedBytesDeserializer {
+            value: value,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl_copy_clone!(BorrowedBytesDeserializer<'de>);
+
+impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
+where
+    E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
    {
        visitor.visit_borrowed_bytes(self.value)
    }
@@ -701,14 +866,23 @@ where
    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any enum
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("BorrowedBytesDeserializer")
+            .field("value", &self.value)
+            .finish()
    }
 }

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

 /// A deserializer that iterates over a sequence.
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct SeqDeserializer<I, E> {
    iter: iter::Fuse<I>,
    count: usize,
@@ -813,6 +987,19 @@ impl Expected for ExpectedInSeq {
    }
 }

+impl<I, E> Debug for SeqDeserializer<I, E>
+where
+    I: Debug,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("SeqDeserializer")
+            .field("iter", &self.iter)
+            .field("count", &self.count)
+            .finish()
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////

 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -1108,7 +1295,6 @@ where
    }
 }

-// Cannot #[derive(Debug)] because of the bound `Second<I::Item>: Debug`.
 impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
 where
    I: Iterator + Debug,
@@ -1121,8 +1307,6 @@ where
            .field("iter", &self.iter)
            .field("value", &self.value)
            .field("count", &self.count)
-            .field("lifetime", &self.lifetime)
-            .field("error", &self.error)
            .finish()
    }
 }
@@ -1317,7 +1501,7 @@ where
    where
        T: de::DeserializeSeed<'de>,
    {
-        match self.map.next_key_seed(seed)? {
+        match try!(self.map.next_key_seed(seed)) {
            Some(key) => Ok((key, private::map_as_enum(self.map))),
            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
        }
@@ -1326,12 +1510,46 @@ where

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

+/// A deserializer holding an `EnumAccess`.
+#[derive(Clone, Debug)]
+pub struct EnumAccessDeserializer<A> {
+    access: A,
+}
+
+impl<A> EnumAccessDeserializer<A> {
+    /// Construct a new `EnumAccessDeserializer<A>`.
+    pub fn new(access: A) -> Self {
+        EnumAccessDeserializer { access: access }
+    }
+}
+
+impl<'de, A> de::Deserializer<'de> for EnumAccessDeserializer<A>
+where
+    A: de::EnumAccess<'de>,
+{
+    type Error = A::Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_enum(self.access)
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 mod private {
    use lib::*;

    use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};

-    #[derive(Clone, Debug)]
    pub struct UnitOnly<E> {
        marker: PhantomData<E>,
    }
@@ -1390,7 +1608,6 @@ mod private {
        }
    }

-    #[derive(Clone, Debug)]
    pub struct MapAsEnum<A> {
        map: A,
    }
@@ -1,39 +0,0 @@
-pub use lib::clone::Clone;
-pub use lib::convert::{From, Into};
-pub use lib::default::Default;
-pub use lib::fmt::{self, Formatter};
-pub use lib::marker::PhantomData;
-pub use lib::option::Option::{self, None, Some};
-pub use lib::result::Result::{self, Err, Ok};
-
-pub use self::string::from_utf8_lossy;
-
-#[cfg(any(feature = "alloc", feature = "std"))]
-pub use lib::{ToString, Vec};
-
-#[cfg(core_try_from)]
-pub use lib::convert::TryFrom;
-
-mod string {
-    use lib::*;
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
-        String::from_utf8_lossy(bytes)
-    }
-
-    // The generated code calls this like:
-    //
-    //     let value = &_serde::export::from_utf8_lossy(bytes);
-    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
-    //
-    // so it is okay for the return type to be different from the std case as long
-    // as the above works.
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
-        // Three unicode replacement characters if it fails. They look like a
-        // white-on-black question mark. The user will recognize it as invalid
-        // UTF-8.
-        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
-    }
-}
@@ -10,7 +10,7 @@
 /// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
-/// # use serde::private::ser::Error;
+/// # use serde::__private::doc::Error;
 /// #
 /// # struct MySerializer;
 /// #
@@ -66,7 +66,7 @@
 ///     ($($tt:tt)*) => {};
 /// }
 /// ```
-#[cfg(integer128)]
+#[cfg(not(no_integer128))]
 #[macro_export]
 macro_rules! serde_if_integer128 {
    ($($tt:tt)*) => {
@@ -74,7 +74,7 @@ macro_rules! serde_if_integer128 {
    };
 }

-#[cfg(not(integer128))]
+#[cfg(no_integer128)]
 #[macro_export]
 #[doc(hidden)]
 macro_rules! serde_if_integer128 {
@@ -9,11 +9,9 @@
 //! these two groups interact with each other, allowing any supported data
 //! structure to be serialized and deserialized using any supported data format.
 //!
-//! See the Serde website [https://serde.rs/] for additional documentation and
+//! See the Serde website <https://serde.rs/> for additional documentation and
 //! usage examples.
 //!
-//! [https://serde.rs/]: https://serde.rs/
-//!
 //! ## Design
 //!
 //! Where many other languages rely on runtime reflection for serializing data,
@@ -33,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
@@ -46,9 +43,10 @@
 //! - [BSON], the data storage and network transfer format used by MongoDB.
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
-//! - [JSON5], A superset of JSON including some productions from ES5.
-//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
+//! - [JSON5], a superset of JSON including some productions from ES5.
 //! - [URL] query strings, in the x-www-form-urlencoded format.
+//! - [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
@@ -56,54 +54,66 @@
 //! - [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/servo/bincode
-//! [CBOR]: https://github.com/pyfisch/cbor
+//! [Postcard]: https://github.com/jamesmunns/postcard
+//! [CBOR]: https://github.com/enarx/ciborium
 //! [YAML]: https://github.com/dtolnay/serde-yaml
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
-//! [TOML]: https://github.com/alexcrichton/toml-rs
+//! [TOML]: https://docs.rs/toml
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [RON]: https://github.com/ron-rs/ron
-//! [BSON]: https://github.com/zonyitoo/bson-rs
-//! [Avro]: https://github.com/flavray/avro-rs
+//! [BSON]: https://github.com/mongodb/bson-rust
+//! [Avro]: https://docs.rs/apache-avro
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
-//! [Postcard]: https://github.com/jamesmunns/postcard
 //! [URL]: https://docs.rs/serde_qs
+//! [Starlark]: https://github.com/dtolnay/serde-starlark
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
-//! [Cargo]: http://doc.crates.io/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
+//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
+//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
 //! [S-expressions]: https://github.com/rotty/lexpr-rs
 //! [D-Bus]: https://docs.rs/zvariant
 //! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
+//! [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.117")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.156")]
 // 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))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy and clippy_pedantic lints
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
        unnested_or_patterns,
+        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
+        semicolon_if_nothing_returned,
        // not available in our oldest supported compiler
-        checked_conversions,
        empty_enum,
-        redundant_field_names,
-        redundant_static_lifetimes,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
        // integer and float ser/de requires these sorts of casts
        cast_possible_truncation,
        cast_possible_wrap,
@@ -117,8 +127,13 @@
        use_self,
        zero_prefixed_literal,
        // correctly used
+        derive_partial_eq_without_eq,
        enum_glob_use,
+        explicit_auto_deref,
+        let_underscore_untyped,
        map_err_ignore,
+        new_without_default,
+        result_unit_err,
        wildcard_imports,
        // not practical
        needless_pass_by_value,
@@ -135,7 +150,6 @@
    )
 )]
 // Rustc lints.
-#![forbid(unsafe_code)]
 #![deny(missing_docs, unused_imports)]

 ////////////////////////////////////////////////////////////////////////////////
@@ -154,7 +168,7 @@ mod lib {
        pub use std::*;
    }

-    pub use self::core::{cmp, iter, mem, num, slice, str};
+    pub use self::core::{cmp, iter, mem, num, ptr, slice, str};
    pub use self::core::{f32, f64};
    pub use self::core::{i16, i32, i64, i8, isize};
    pub use self::core::{u16, u32, u64, u8, usize};
@@ -165,6 +179,7 @@ mod lib {
    pub use self::core::default::{self, Default};
    pub use self::core::fmt::{self, Debug, Display};
    pub use self::core::marker::{self, PhantomData};
+    pub use self::core::num::Wrapping;
    pub use self::core::ops::Range;
    pub use self::core::option::{self, Option};
    pub use self::core::result::{self, Result};
@@ -204,50 +219,84 @@ 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")]
    pub use std::io::Write;
    #[cfg(feature = "std")]
-    pub use std::num::Wrapping;
-    #[cfg(feature = "std")]
    pub use std::path::{Path, PathBuf};
    #[cfg(feature = "std")]
    pub use std::sync::{Mutex, RwLock};
    #[cfg(feature = "std")]
    pub use std::time::{SystemTime, UNIX_EPOCH};

-    #[cfg(all(feature = "std", collections_bound))]
+    #[cfg(all(feature = "std", not(no_collections_bound), no_ops_bound))]
    pub use std::collections::Bound;

-    #[cfg(core_reverse)]
+    #[cfg(not(no_core_reverse))]
    pub use self::core::cmp::Reverse;

-    #[cfg(ops_bound)]
+    #[cfg(not(no_ops_bound))]
    pub use self::core::ops::Bound;

-    #[cfg(range_inclusive)]
+    #[cfg(not(no_range_inclusive))]
    pub use self::core::ops::RangeInclusive;

-    #[cfg(all(feature = "std", std_atomic))]
+    #[cfg(all(feature = "std", 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", std_atomic64))]
+    #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic64)))]
    pub use std::sync::atomic::{AtomicI64, AtomicU64};

-    #[cfg(any(core_duration, feature = "std"))]
+    #[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]
@@ -264,15 +313,20 @@ pub use de::{Deserialize, Deserializer};
 #[doc(inline)]
 pub use ser::{Serialize, Serializer};

-// Generated code uses these to support no_std. Not public API.
+// Used by generated code and doc tests. Not public API.
 #[doc(hidden)]
-pub mod export;
+#[path = "private/mod.rs"]
+pub mod __private;

-// Helpers used by generated code and doc tests. Not public API.
-#[doc(hidden)]
-pub mod private;
+#[allow(unused_imports)]
+use self::__private as export;
+#[allow(unused_imports)]
+use self::__private as private;

-#[cfg(not(feature = "std"))]
+#[path = "de/seed.rs"]
+mod seed;
+
+#[cfg(not(any(feature = "std", feature = "unstable")))]
 mod std_error;

 // Re-export #[derive(Serialize, Deserialize)].
@@ -284,6 +338,12 @@ 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 {
+    pub struct T;
+}
@@ -124,7 +124,7 @@ macro_rules! forward_to_deserialize_any {
 macro_rules! forward_to_deserialize_any_method {
    ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
        #[inline]
-        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::export::Result<$v::Value, Self::Error>
+        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
        where
            $v: $crate::de::Visitor<$l>,
        {
@@ -1,9 +1,10 @@
 use lib::*;

-use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
+use de::value::{BorrowedBytesDeserializer, BytesDeserializer};
+use de::{Deserialize, Deserializer, Error, IntoDeserializer, Visitor};

 #[cfg(any(feature = "std", feature = "alloc"))]
-use de::{MapAccess, Unexpected};
+use de::{DeserializeSeed, MapAccess, Unexpected};

 #[cfg(any(feature = "std", feature = "alloc"))]
 pub use self::content::{
@@ -12,6 +13,8 @@ pub use self::content::{
    TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
 };

+pub use seed::InPlaceSeed;
+
 /// If the missing field is of type `Option<T>` then treat is as `None`,
 /// otherwise it is an error.
 pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
@@ -188,29 +191,6 @@ where
        .map(From::from)
 }

-pub mod size_hint {
-    use lib::*;
-
-    pub fn from_bounds<I>(iter: &I) -> Option<usize>
-    where
-        I: Iterator,
-    {
-        helper(iter.size_hint())
-    }
-
-    #[inline]
-    pub fn cautious(hint: Option<usize>) -> usize {
-        cmp::min(hint.unwrap_or(0), 4096)
-    }
-
-    fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
-        match bounds {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 mod content {
    // This module is private and nothing here should be used outside of
@@ -225,7 +205,8 @@ mod content {

    use lib::*;

-    use super::size_hint;
+    use __private::size_hint;
+    use actually_private;
    use de::{
        self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
        MapAccess, SeqAccess, Unexpected, Visitor,
@@ -235,7 +216,7 @@ mod content {
    /// deserializing untagged enums and internally tagged enums.
    ///
    /// Not public API. Use serde-value instead.
-    #[derive(Debug)]
+    #[derive(Debug, Clone)]
    pub enum Content<'de> {
        Bool(bool),

@@ -314,7 +295,7 @@ mod content {
            // Untagged and internally tagged enums are only supported in
            // self-describing formats.
            let visitor = ContentVisitor { value: PhantomData };
-            deserializer.deserialize_any(visitor)
+            deserializer.__deserialize_content(actually_private::T, visitor)
        }
    }

@@ -824,15 +805,17 @@ mod content {
    /// Not public API.
    pub struct TaggedContentVisitor<'de, T> {
        tag_name: &'static str,
+        expecting: &'static str,
        value: PhantomData<TaggedContent<'de, T>>,
    }

    impl<'de, T> TaggedContentVisitor<'de, T> {
        /// Visitor for the content of an internally tagged enum with the given
        /// tag name.
-        pub fn new(name: &'static str) -> Self {
+        pub fn new(name: &'static str, expecting: &'static str) -> Self {
            TaggedContentVisitor {
                tag_name: name,
+                expecting: expecting,
                value: PhantomData,
            }
        }
@@ -861,7 +844,7 @@ mod content {
        type Value = TaggedContent<'de, T>;

        fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            fmt.write_str("internally tagged enum")
+            fmt.write_str(self.expecting)
        }

        fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
@@ -1040,6 +1023,25 @@ mod content {
                _ => Err(self.invalid_type(&visitor)),
            }
        }
+
+        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
    }

    fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E>
@@ -1179,25 +1181,14 @@ mod content {
        where
            V: Visitor<'de>,
        {
-            match self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
        }

        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
        {
-            match self.content {
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
        }

        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -1271,6 +1262,17 @@ mod content {
        {
            match self.content {
                Content::Unit => visitor.visit_unit(),
+
+                // Allow deserializing newtype variant containing unit.
+                //
+                //     #[derive(Deserialize)]
+                //     #[serde(tag = "result")]
+                //     enum Response<T> {
+                //         Success(T),
+                //     }
+                //
+                // We want {"result":"Success"} to deserialize into Response<()>.
+                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
                _ => Err(self.invalid_type(&visitor)),
            }
        }
@@ -1297,8 +1299,9 @@ mod content {
                //     }
                //
                // We want {"topic":"Info"} to deserialize even though
-                // ordinarily unit structs do not deserialize from empty map.
+                // ordinarily unit structs do not deserialize from empty map/seq.
                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
+                Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(),
                _ => self.deserialize_any(visitor),
            }
        }
@@ -1436,6 +1439,18 @@ mod content {
            drop(self);
            visitor.visit_unit()
        }
+
+        fn __deserialize_content<V>(
+            self,
+            _: actually_private::T,
+            visitor: V,
+        ) -> Result<Content<'de>, Self::Error>
+        where
+            V: Visitor<'de, Value = Content<'de>>,
+        {
+            let _ = visitor;
+            Ok(self.content)
+        }
    }

    impl<'de, E> ContentDeserializer<'de, E> {
@@ -1751,6 +1766,25 @@ mod content {
                _ => Err(self.invalid_type(&visitor)),
            }
        }
+
+        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
    }

    fn visit_content_seq_ref<'a, 'de, V, E>(
@@ -1776,7 +1810,7 @@ mod content {
        V: Visitor<'de>,
        E: de::Error,
    {
-        let map = content.iter().map(|&(ref k, ref v)| {
+        let map = content.iter().map(|(k, v)| {
            (
                ContentRefDeserializer::new(k),
                ContentRefDeserializer::new(v),
@@ -1898,25 +1932,14 @@ mod content {
        where
            V: Visitor<'de>,
        {
-            match *self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
        }

        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
        {
-            match *self.content {
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
        }

        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -2084,7 +2107,7 @@ mod content {
            let (variant, value) = match *self.content {
                Content::Map(ref value) => {
                    let mut iter = value.iter();
-                    let &(ref variant, ref value) = match iter.next() {
+                    let (variant, value) = match iter.next() {
                        Some(v) => v,
                        None => {
                            return Err(de::Error::invalid_value(
@@ -2139,6 +2162,18 @@ mod content {
        {
            visitor.visit_unit()
        }
+
+        fn __deserialize_content<V>(
+            self,
+            _: actually_private::T,
+            visitor: V,
+        ) -> Result<Content<'de>, Self::Error>
+        where
+            V: Visitor<'de, Value = Content<'de>>,
+        {
+            let _ = visitor;
+            Ok(self.content.clone())
+        }
    }

    impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
@@ -2219,7 +2254,7 @@ mod content {
            V: de::Visitor<'de>,
        {
            match self.value {
-                Some(&Content::Seq(ref v)) => {
+                Some(Content::Seq(v)) => {
                    de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                }
                Some(other) => Err(de::Error::invalid_type(
@@ -2242,10 +2277,10 @@ mod content {
            V: de::Visitor<'de>,
        {
            match self.value {
-                Some(&Content::Map(ref v)) => {
+                Some(Content::Map(v)) => {
                    de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
                }
-                Some(&Content::Seq(ref v)) => {
+                Some(Content::Seq(v)) => {
                    de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                }
                Some(other) => Err(de::Error::invalid_type(
@@ -2368,7 +2403,7 @@ mod content {
            T: de::DeserializeSeed<'de>,
        {
            match self.iter.next() {
-                Some(&(ref key, ref value)) => {
+                Some((key, value)) => {
                    self.value = Some(value);
                    seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
                }
@@ -2542,11 +2577,13 @@ pub trait IdentifierDeserializer<'de, E: Error> {
    fn from(self) -> Self::Deserializer;
 }

-impl<'de, E> IdentifierDeserializer<'de, E> for u32
+pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
+
+impl<'de, E> IdentifierDeserializer<'de, E> for u64
 where
    E: Error,
 {
-    type Deserializer = <u32 as IntoDeserializer<'de, E>>::Deserializer;
+    type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;

    fn from(self) -> Self::Deserializer {
        self.into_deserializer()
@@ -2558,20 +2595,6 @@ pub struct StrDeserializer<'a, E> {
    marker: PhantomData<E>,
 }

-impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
-where
-    E: Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        StrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
 where
    E: Error,
@@ -2592,26 +2615,12 @@ where
    }
 }

-pub struct BytesDeserializer<'a, E> {
-    value: &'a [u8],
+pub struct BorrowedStrDeserializer<'de, E> {
+    value: &'de str,
    marker: PhantomData<E>,
 }

-impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
-where
-    E: Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BytesDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
+impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
 where
    E: Error,
 {
@@ -2621,7 +2630,7 @@ where
    where
        V: Visitor<'de>,
    {
-        visitor.visit_bytes(self.value)
+        visitor.visit_borrowed_str(self.value)
    }

    forward_to_deserialize_any! {
@@ -2631,21 +2640,53 @@ where
    }
 }

-/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
-///
-/// Wraps a mutable reference and calls deserialize_in_place on it.
-pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
-
-impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
 where
-    T: Deserialize<'de>,
+    E: Error,
 {
-    type Value = ();
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize_in_place(deserializer, self.0)
+    type Deserializer = StrDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        StrDeserializer {
+            value: self,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedStrDeserializer<'de, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BorrowedStrDeserializer {
+            value: self.0,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
+where
+    E: Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BytesDeserializer::new(self)
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedBytesDeserializer<'de, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BorrowedBytesDeserializer::new(self.0)
    }
 }

@@ -2667,7 +2708,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
@@ -2827,7 +2868,7 @@ where
    where
        T: DeserializeSeed<'de>,
    {
-        while let Some(item) = self.iter.next() {
+        for item in &mut self.iter {
            // Items in the vector are nulled out when used by a struct.
            if let Some((ref key, ref content)) = *item {
                self.pending_content = Some(content);
@@ -2929,7 +2970,7 @@ where
    where
        T: DeserializeSeed<'de>,
    {
-        while let Some(item) = self.iter.next() {
+        for item in &mut self.iter {
            if let Some((ref key, ref content)) = *item {
                // Do not take(), instead borrow this entry. The internally tagged
                // enum does its own buffering so we can't tell whether this entry
@@ -1,3 +1,35 @@
+// Used only by Serde doc tests. Not public API.
+
+use lib::*;
+
+use ser;
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct Error;
+
+impl ser::Error for Error {
+    fn custom<T>(_: T) -> Self
+    where
+        T: Display,
+    {
+        unimplemented!()
+    }
+}
+
+#[cfg(feature = "std")]
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        unimplemented!()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+        unimplemented!()
+    }
+}
+
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __private_serialize {
@@ -10,19 +42,6 @@ macro_rules! __private_serialize {
    };
 }

-#[doc(hidden)]
-#[macro_export]
-macro_rules! __private_deserialize {
-    () => {
-        trait Deserialize<'de>: Sized {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: $crate::Deserializer<'de>;
-        }
-    };
-}
-
-/// Used only by Serde doc tests. Not public API.
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
 macro_rules! __serialize_unimplemented {
@@ -37,7 +56,7 @@ macro_rules! __serialize_unimplemented {
 #[macro_export]
 macro_rules! __serialize_unimplemented_method {
    ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
-        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::export::Result<Self::$ret, Self::Error> {
+        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
            unimplemented!()
        }
    };
@@ -1,4 +1,50 @@
-mod macros;
-
+#[cfg(not(no_serde_derive))]
 pub mod de;
+#[cfg(not(no_serde_derive))]
 pub mod ser;
+
+pub mod size_hint;
+
+// FIXME: #[cfg(doctest)] once https://github.com/rust-lang/rust/issues/67295 is fixed.
+pub mod doc;
+
+pub use lib::clone::Clone;
+pub use lib::convert::{From, Into};
+pub use lib::default::Default;
+pub use lib::fmt::{self, Formatter};
+pub use lib::marker::PhantomData;
+pub use lib::option::Option::{self, None, Some};
+pub use lib::ptr;
+pub use lib::result::Result::{self, Err, Ok};
+
+pub use self::string::from_utf8_lossy;
+
+#[cfg(any(feature = "alloc", feature = "std"))]
+pub use lib::{ToString, Vec};
+
+#[cfg(not(no_core_try_from))]
+pub use lib::convert::TryFrom;
+
+mod string {
+    use lib::*;
+
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
+        String::from_utf8_lossy(bytes)
+    }
+
+    // The generated code calls this like:
+    //
+    //     let value = &_serde::__private::from_utf8_lossy(bytes);
+    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
+    //
+    // so it is okay for the return type to be different from the std case as long
+    // as the above works.
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
+    pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
+        // Three unicode replacement characters if it fails. They look like a
+        // white-on-black question mark. The user will recognize it as invalid
+        // UTF-8.
+        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
+    }
+}
@@ -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> {
@@ -335,33 +335,6 @@ where
    }
 }

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

-    #[derive(Debug)]
    pub enum Content {
        Bool(bool),

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

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

-#[cfg(range_inclusive)]
+#[cfg(not(no_range_inclusive))]
 impl<Idx> Serialize for RangeInclusive<Idx>
 where
    Idx: Serialize,
@@ -258,7 +276,7 @@ where

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

-#[cfg(any(ops_bound, collections_bound))]
+#[cfg(any(not(no_ops_bound), all(feature = "std", not(no_collections_bound))))]
 impl<T> Serialize for Bound<T>
 where
    T: Serialize,
@@ -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,9 +502,9 @@ where
 ////////////////////////////////////////////////////////////////////////////////

 macro_rules! nonzero_integers {
-    ( $( $T: ident, )+ ) => {
+    ($($T:ident,)+) => {
        $(
-            #[cfg(num_nonzero)]
+            #[cfg(not(no_num_nonzero))]
            impl Serialize for num::$T {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
@@ -488,7 +525,7 @@ nonzero_integers! {
    NonZeroUsize,
 }

-#[cfg(num_nonzero_signed)]
+#[cfg(not(no_num_nonzero_signed))]
 nonzero_integers! {
    NonZeroI8,
    NonZeroI16,
@@ -504,7 +541,7 @@ serde_if_integer128! {
        NonZeroU128,
    }

-    #[cfg(num_nonzero_signed)]
+    #[cfg(not(no_num_nonzero_signed))]
    nonzero_integers! {
        NonZeroI128,
    }
@@ -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,
 {
@@ -591,7 +628,7 @@ where

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

-#[cfg(any(core_duration, feature = "std"))]
+#[cfg(any(feature = "std", not(no_core_duration)))]
 impl Serialize for Duration {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@@ -614,9 +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()));
@@ -674,6 +712,52 @@ impl Serialize for net::IpAddr {
    }
 }

+#[cfg(feature = "std")]
+const DEC_DIGITS_LUT: &'static [u8] = b"\
+      0001020304050607080910111213141516171819\
+      2021222324252627282930313233343536373839\
+      4041424344454647484950515253545556575859\
+      6061626364656667686970717273747576777879\
+      8081828384858687888990919293949596979899";
+
+#[cfg(feature = "std")]
+#[inline]
+fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
+    if n >= 100 {
+        let d1 = ((n % 100) << 1) as usize;
+        n /= 100;
+        out[0] = b'0' + n;
+        out[1] = DEC_DIGITS_LUT[d1];
+        out[2] = DEC_DIGITS_LUT[d1 + 1];
+        3
+    } else if n >= 10 {
+        let d1 = (n << 1) as usize;
+        out[0] = DEC_DIGITS_LUT[d1];
+        out[1] = DEC_DIGITS_LUT[d1 + 1];
+        2
+    } else {
+        out[0] = b'0' + n;
+        1
+    }
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn test_format_u8() {
+    let mut i = 0u8;
+
+    loop {
+        let mut buf = [0u8; 3];
+        let written = format_u8(i, &mut buf);
+        assert_eq!(i.to_string().as_bytes(), &buf[..written]);
+
+        match i.checked_add(1) {
+            Some(next) => i = next,
+            None => break,
+        }
+    }
+}
+
 #[cfg(feature = "std")]
 impl Serialize for net::Ipv4Addr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -683,7 +767,15 @@ impl Serialize for net::Ipv4Addr {
        if serializer.is_human_readable() {
            const MAX_LEN: usize = 15;
            debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+            let mut buf = [b'.'; MAX_LEN];
+            let mut written = format_u8(self.octets()[0], &mut buf);
+            for oct in &self.octets()[1..] {
+                // Skip over delimiters that we initialized buf with
+                written += format_u8(*oct, &mut buf[written + 1..]) + 1;
+            }
+            // 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)
        }
@@ -824,7 +916,6 @@ impl Serialize for OsString {

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

-#[cfg(feature = "std")]
 impl<T> Serialize for Wrapping<T>
 where
    T: Serialize,
@@ -838,7 +929,7 @@ where
    }
 }

-#[cfg(core_reverse)]
+#[cfg(not(no_core_reverse))]
 impl<T> Serialize for Reverse<T>
 where
    T: Serialize,
@@ -854,30 +945,39 @@ where

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

-#[cfg(all(feature = "std", std_atomic))]
+#[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,
                {
-                    self.load(Ordering::SeqCst).serialize(serializer)
+                    // Matches the atomic ordering used in libcore for the Debug impl
+                    self.load(Ordering::Relaxed).serialize(serializer)
                }
            }
        )*
    }
 }

-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 atomic_impl! {
-    AtomicBool
-    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
-    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+    AtomicBool "8"
+    AtomicI8 "8"
+    AtomicI16 "16"
+    AtomicI32 "32"
+    AtomicIsize "ptr"
+    AtomicU8 "8"
+    AtomicU16 "16"
+    AtomicU32 "32"
+    AtomicUsize "ptr"
 }

-#[cfg(all(feature = "std", std_atomic64))]
+#[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
-    AtomicI64 AtomicU64
+    AtomicI64 "64"
+    AtomicU64 "64"
 }
@@ -17,7 +17,7 @@ use ser::{
 ///
 /// ```edition2018
 /// # use serde::ser::{Serializer, Impossible};
-/// # use serde::private::ser::Error;
+/// # use serde::__private::doc::Error;
 /// #
 /// # struct MySerializer;
 /// #
@@ -30,7 +30,7 @@
 //! # The Serializer trait
 //!
 //! [`Serializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
+//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
 //!
 //! A partial list of well-maintained formats is given on the [Serde
 //! website][data formats].
@@ -99,7 +99,7 @@
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
 //! [`Serialize`]: ../trait.Serialize.html
 //! [`Serializer`]: ../trait.Serializer.html
-//! [`bincode`]: https://github.com/servo/bincode
+//! [`postcard`]: https://github.com/jamesmunns/postcard
 //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
@@ -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
@@ -711,7 +713,7 @@ pub trait Serializer: Sized {
    ///
    /// ```edition2018
    /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::private::ser::Error;
+    /// # use serde::__private::doc::Error;
    /// #
    /// # struct MySerializer;
    /// #
@@ -1279,9 +1281,20 @@ pub trait Serializer: Sized {
    {
        let iter = iter.into_iter();
        let mut serializer = try!(self.serialize_seq(iterator_len_hint(&iter)));
-        for item in iter {
-            try!(serializer.serialize_element(&item));
+
+        #[cfg(not(no_iterator_try_fold))]
+        {
+            let mut iter = iter;
+            try!(iter.try_for_each(|item| serializer.serialize_element(&item)));
        }
+
+        #[cfg(no_iterator_try_fold)]
+        {
+            for item in iter {
+                try!(serializer.serialize_element(&item));
+            }
+        }
+
        serializer.end()
    }

@@ -1319,9 +1332,20 @@ pub trait Serializer: Sized {
    {
        let iter = iter.into_iter();
        let mut serializer = try!(self.serialize_map(iterator_len_hint(&iter)));
-        for (key, value) in iter {
-            try!(serializer.serialize_entry(&key, &value));
+
+        #[cfg(not(no_iterator_try_fold))]
+        {
+            let mut iter = iter;
+            try!(iter.try_for_each(|(key, value)| serializer.serialize_entry(&key, &value)));
        }
+
+        #[cfg(no_iterator_try_fold)]
+        {
+            for (key, value) in iter {
+                try!(serializer.serialize_entry(&key, &value));
+            }
+        }
+
        serializer.end()
    }

@@ -1401,7 +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
@@ -0,0 +1 @@
+msrv = "1.31.0"
@@ -1,15 +1,17 @@
 [package]
 name = "serde_derive"
-version = "1.0.117" # remember to update html_root_url
+version = "1.0.156" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT OR Apache-2.0"
+categories = ["no-std"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
 documentation = "https://serde.rs/derive.html"
-keywords = ["serde", "serialization", "no_std"]
-readme = "crates-io.md"
+homepage = "https://serde.rs"
 include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization", "no_std", "derive"]
+license = "MIT OR Apache-2.0"
+readme = "crates-io.md"
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.31"

 [features]
 default = []
@@ -22,7 +24,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.33", features = ["visit"] }
+syn = "1.0.104"

 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }
@@ -6,6 +6,8 @@ use std::str;
 // 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,14 @@ fn main() {

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

@@ -2,7 +2,6 @@ use std::collections::HashSet;

 use syn;
 use syn::punctuated::{Pair, Punctuated};
-use syn::visit::{self, Visit};

 use internals::ast::{Container, Data};
 use internals::{attr, ungroup};
@@ -50,8 +49,8 @@ pub fn with_where_predicates_from_fields(
    let predicates = cont
        .data
        .all_fields()
-        .flat_map(|field| from_field(&field.attrs))
-        .flat_map(|predicates| predicates.to_vec());
+        .filter_map(|field| from_field(&field.attrs))
+        .flat_map(<[syn::WherePredicate]>::to_vec);

    let mut generics = generics.clone();
    generics.make_where_clause().predicates.extend(predicates);
@@ -72,8 +71,8 @@ pub fn with_where_predicates_from_variants(

    let predicates = variants
        .iter()
-        .flat_map(|variant| from_variant(&variant.attrs))
-        .flat_map(|predicates| predicates.to_vec());
+        .filter_map(|variant| from_variant(&variant.attrs))
+        .flat_map(<[syn::WherePredicate]>::to_vec);

    let mut generics = generics.clone();
    generics.make_where_clause().predicates.extend(predicates);
@@ -112,7 +111,8 @@ pub fn with_bound(
        // parameters.
        associated_type_usage: Vec<&'ast syn::TypePath>,
    }
-    impl<'ast> Visit<'ast> for FindTyParams<'ast> {
+
+    impl<'ast> FindTyParams<'ast> {
        fn visit_field(&mut self, field: &'ast syn::Field) {
            if let syn::Type::Path(ty) = ungroup(&field.ty) {
                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
@@ -138,7 +138,96 @@ pub fn with_bound(
                    self.relevant_type_params.insert(id.clone());
                }
            }
-            visit::visit_path(self, path);
+            for segment in &path.segments {
+                self.visit_path_segment(segment);
+            }
+        }
+
+        // Everything below is simply traversing the syntax tree.
+
+        fn visit_type(&mut self, ty: &'ast syn::Type) {
+            match ty {
+                syn::Type::Array(ty) => self.visit_type(&ty.elem),
+                syn::Type::BareFn(ty) => {
+                    for arg in &ty.inputs {
+                        self.visit_type(&arg.ty);
+                    }
+                    self.visit_return_type(&ty.output);
+                }
+                syn::Type::Group(ty) => self.visit_type(&ty.elem),
+                syn::Type::ImplTrait(ty) => {
+                    for bound in &ty.bounds {
+                        self.visit_type_param_bound(bound);
+                    }
+                }
+                syn::Type::Macro(ty) => self.visit_macro(&ty.mac),
+                syn::Type::Paren(ty) => self.visit_type(&ty.elem),
+                syn::Type::Path(ty) => {
+                    if let Some(qself) = &ty.qself {
+                        self.visit_type(&qself.ty);
+                    }
+                    self.visit_path(&ty.path);
+                }
+                syn::Type::Ptr(ty) => self.visit_type(&ty.elem),
+                syn::Type::Reference(ty) => self.visit_type(&ty.elem),
+                syn::Type::Slice(ty) => self.visit_type(&ty.elem),
+                syn::Type::TraitObject(ty) => {
+                    for bound in &ty.bounds {
+                        self.visit_type_param_bound(bound);
+                    }
+                }
+                syn::Type::Tuple(ty) => {
+                    for elem in &ty.elems {
+                        self.visit_type(elem);
+                    }
+                }
+
+                syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
+
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                _ => {}
+            }
+        }
+
+        fn visit_path_segment(&mut self, segment: &'ast syn::PathSegment) {
+            self.visit_path_arguments(&segment.arguments);
+        }
+
+        fn visit_path_arguments(&mut self, arguments: &'ast syn::PathArguments) {
+            match arguments {
+                syn::PathArguments::None => {}
+                syn::PathArguments::AngleBracketed(arguments) => {
+                    for arg in &arguments.args {
+                        match arg {
+                            syn::GenericArgument::Type(arg) => self.visit_type(arg),
+                            syn::GenericArgument::Binding(arg) => self.visit_type(&arg.ty),
+                            syn::GenericArgument::Lifetime(_)
+                            | syn::GenericArgument::Constraint(_)
+                            | syn::GenericArgument::Const(_) => {}
+                        }
+                    }
+                }
+                syn::PathArguments::Parenthesized(arguments) => {
+                    for argument in &arguments.inputs {
+                        self.visit_type(argument);
+                    }
+                    self.visit_return_type(&arguments.output);
+                }
+            }
+        }
+
+        fn visit_return_type(&mut self, return_type: &'ast syn::ReturnType) {
+            match return_type {
+                syn::ReturnType::Default => {}
+                syn::ReturnType::Type(_, output) => self.visit_type(output),
+            }
+        }
+
+        fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
+            match bound {
+                syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
+                syn::TypeParamBound::Lifetime(_) => {}
+            }
        }

        // Type parameter should not be considered used by a macro path.
@@ -12,10 +12,10 @@ pub fn wrap_in_const(
 ) -> TokenStream {
    let try_replacement = try::replacement();

-    let dummy_const = if cfg!(underscore_consts) {
-        format_ident!("_")
-    } else {
+    let dummy_const = if cfg!(no_underscore_consts) {
        format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
+    } else {
+        format_ident!("_")
    };

    let use_serde = match serde_path {
@@ -23,7 +23,7 @@ pub fn wrap_in_const(
            use #path as _serde;
        },
        None => quote! {
-            #[allow(rust_2018_idioms, clippy::useless_attribute)]
+            #[allow(unused_extern_crates, clippy::useless_attribute)]
            extern crate serde as _serde;
        },
    };
@@ -39,10 +39,6 @@ pub fn wrap_in_const(
    }
 }

-#[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()
+    ident.to_string().trim_start_matches("r#").to_owned()
 }
@@ -23,7 +23,7 @@ pub struct Container<'a> {

 /// The fields of a struct or enum.
 ///
-/// Analagous to `syn::Data`.
+/// Analogous to `syn::Data`.
 pub enum Data<'a> {
    Enum(Vec<Variant<'a>>),
    Struct(Style, Vec<Field<'a>>),
@@ -1,16 +1,16 @@
 use internals::symbol::*;
 use internals::{ungroup, Ctxt};
-use proc_macro2::{Group, Span, TokenStream, TokenTree};
+use proc_macro2::{Spacing, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use std::borrow::Cow;
 use std::collections::BTreeSet;
-use std::str::FromStr;
+use std::iter::FromIterator;
 use syn;
-use syn::parse::{self, Parse, ParseStream};
+use syn::parse::ParseStream;
 use syn::punctuated::Punctuated;
-use syn::Ident;
 use syn::Meta::{List, NameValue, Path};
 use syn::NestedMeta::{Lit, Meta};
+use syn::{Ident, Lifetime};

 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
 // are `attr::Container::from_ast`, `attr::Variant::from_ast`, and
@@ -141,12 +141,8 @@ pub struct Name {
    deserialize_aliases: Vec<String>,
 }

-#[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()
+    ident.to_string().trim_start_matches("r#").to_owned()
 }

 impl Name {
@@ -223,6 +219,8 @@ pub struct Container {
    has_flatten: bool,
    serde_path: Option<syn::Path>,
    is_packed: bool,
+    /// Error message generated when type can't be deserialized
+    expecting: Option<String>,
 }

 /// Styles of representing an enum.
@@ -305,6 +303,7 @@ impl Container {
        let mut field_identifier = BoolAttr::none(cx, FIELD_IDENTIFIER);
        let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
        let mut serde_path = Attr::none(cx, CRATE);
+        let mut expecting = Attr::none(cx, EXPECTING);

        for meta_item in item
            .attrs
@@ -337,13 +336,7 @@ impl Container {
                                rename_all_ser_rule.set(&m.path, rename_rule);
                                rename_all_de_rule.set(&m.path, rename_rule);
                            }
-                            Err(()) => cx.error_spanned_by(
-                                s,
-                                format!(
-                                    "unknown rename rule for #[serde(rename_all = {:?})]",
-                                    s.value(),
-                                ),
-                            ),
+                            Err(err) => cx.error_spanned_by(s, err),
                        }
                    }
                }
@@ -354,25 +347,13 @@ impl Container {
                        if let Some(ser) = ser {
                            match RenameRule::from_str(&ser.value()) {
                                Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    ser,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        ser.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(ser, err),
                            }
                        }
                        if let Some(de) = de {
                            match RenameRule::from_str(&de.value()) {
                                Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    de,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        de.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(de, err),
                            }
                        }
                    }
@@ -394,48 +375,43 @@ impl Container {
                        syn::Fields::Named(_) => {
                            default.set(word, Default::Default);
                        }
-                        syn::Fields::Unnamed(_) | syn::Fields::Unit => cx.error_spanned_by(
-                            fields,
-                            "#[serde(default)] can only be used on structs with named fields",
-                        ),
+                        syn::Fields::Unnamed(_) | syn::Fields::Unit => {
+                            let msg =
+                                "#[serde(default)] can only be used on structs with named fields";
+                            cx.error_spanned_by(fields, msg);
+                        }
                    },
-                    syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx.error_spanned_by(
-                        enum_token,
-                        "#[serde(default)] can only be used on structs with named fields",
-                    ),
-                    syn::Data::Union(syn::DataUnion { union_token, .. }) => cx.error_spanned_by(
-                        union_token,
-                        "#[serde(default)] can only be used on structs with named fields",
-                    ),
+                    syn::Data::Enum(syn::DataEnum { enum_token, .. }) => {
+                        let msg = "#[serde(default)] can only be used on structs with named fields";
+                        cx.error_spanned_by(enum_token, msg);
+                    }
+                    syn::Data::Union(syn::DataUnion { union_token, .. }) => {
+                        let msg = "#[serde(default)] can only be used on structs with named fields";
+                        cx.error_spanned_by(union_token, msg);
+                    }
                },

                // Parse `#[serde(default = "...")]`
                Meta(NameValue(m)) if m.path == DEFAULT => {
                    if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
                        match &item.data {
-                            syn::Data::Struct(syn::DataStruct { fields, .. }) => {
-                                match fields {
-                                    syn::Fields::Named(_) => {
-                                        default.set(&m.path, Default::Path(path));
-                                    }
-                                    syn::Fields::Unnamed(_) | syn::Fields::Unit => cx
-                                        .error_spanned_by(
-                                            fields,
-                                            "#[serde(default = \"...\")] can only be used on structs with named fields",
-                                        ),
+                            syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
+                                syn::Fields::Named(_) => {
+                                    default.set(&m.path, Default::Path(path));
                                }
+                                syn::Fields::Unnamed(_) | syn::Fields::Unit => {
+                                    let msg = "#[serde(default = \"...\")] can only be used on structs with named fields";
+                                    cx.error_spanned_by(fields, msg);
+                                }
+                            },
+                            syn::Data::Enum(syn::DataEnum { enum_token, .. }) => {
+                                let msg = "#[serde(default = \"...\")] can only be used on structs with named fields";
+                                cx.error_spanned_by(enum_token, msg);
+                            }
+                            syn::Data::Union(syn::DataUnion { union_token, .. }) => {
+                                let msg = "#[serde(default = \"...\")] can only be used on structs with named fields";
+                                cx.error_spanned_by(union_token, msg);
                            }
-                            syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx
-                                .error_spanned_by(
-                                    enum_token,
-                                    "#[serde(default = \"...\")] can only be used on structs with named fields",
-                                ),
-                            syn::Data::Union(syn::DataUnion {
-                                union_token, ..
-                            }) => cx.error_spanned_by(
-                                union_token,
-                                "#[serde(default = \"...\")] can only be used on structs with named fields",
-                            ),
                        }
                    }
                }
@@ -462,16 +438,12 @@ impl Container {
                        untagged.set_true(word);
                    }
                    syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
-                        cx.error_spanned_by(
-                            struct_token,
-                            "#[serde(untagged)] can only be used on enums",
-                        );
+                        let msg = "#[serde(untagged)] can only be used on enums";
+                        cx.error_spanned_by(struct_token, msg);
                    }
                    syn::Data::Union(syn::DataUnion { union_token, .. }) => {
-                        cx.error_spanned_by(
-                            union_token,
-                            "#[serde(untagged)] can only be used on enums",
-                        );
+                        let msg = "#[serde(untagged)] can only be used on enums";
+                        cx.error_spanned_by(union_token, msg);
                    }
                },

@@ -487,17 +459,13 @@ impl Container {
                                    internal_tag.set(&m.path, s.value());
                                }
                                syn::Fields::Unnamed(_) | syn::Fields::Unit => {
-                                    cx.error_spanned_by(
-                                            fields,
-                                            "#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
-                                        );
+                                    let msg = "#[serde(tag = \"...\")] can only be used on enums and structs with named fields";
+                                    cx.error_spanned_by(fields, msg);
                                }
                            },
                            syn::Data::Union(syn::DataUnion { union_token, .. }) => {
-                                cx.error_spanned_by(
-                                    union_token,
-                                    "#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
-                                );
+                                let msg = "#[serde(tag = \"...\")] can only be used on enums and structs with named fields";
+                                cx.error_spanned_by(union_token, msg);
                            }
                        }
                    }
@@ -511,36 +479,32 @@ impl Container {
                                content.set(&m.path, s.value());
                            }
                            syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
-                                cx.error_spanned_by(
-                                    struct_token,
-                                    "#[serde(content = \"...\")] can only be used on enums",
-                                );
+                                let msg = "#[serde(content = \"...\")] can only be used on enums";
+                                cx.error_spanned_by(struct_token, msg);
                            }
                            syn::Data::Union(syn::DataUnion { union_token, .. }) => {
-                                cx.error_spanned_by(
-                                    union_token,
-                                    "#[serde(content = \"...\")] can only be used on enums",
-                                );
+                                let msg = "#[serde(content = \"...\")] can only be used on enums";
+                                cx.error_spanned_by(union_token, msg);
                            }
                        }
                    }
                }

-                // Parse `#[serde(from = "Type")]
+                // Parse `#[serde(from = "Type")]`
                Meta(NameValue(m)) if m.path == FROM => {
                    if let Ok(from_ty) = parse_lit_into_ty(cx, FROM, &m.lit) {
                        type_from.set_opt(&m.path, Some(from_ty));
                    }
                }

-                // Parse `#[serde(try_from = "Type")]
+                // Parse `#[serde(try_from = "Type")]`
                Meta(NameValue(m)) if m.path == TRY_FROM => {
                    if let Ok(try_from_ty) = parse_lit_into_ty(cx, TRY_FROM, &m.lit) {
                        type_try_from.set_opt(&m.path, Some(try_from_ty));
                    }
                }

-                // Parse `#[serde(into = "Type")]
+                // Parse `#[serde(into = "Type")]`
                Meta(NameValue(m)) if m.path == INTO => {
                    if let Ok(into_ty) = parse_lit_into_ty(cx, INTO, &m.lit) {
                        type_into.set_opt(&m.path, Some(into_ty));
@@ -571,7 +535,14 @@ impl Container {
                // Parse `#[serde(crate = "foo")]`
                Meta(NameValue(m)) if m.path == CRATE => {
                    if let Ok(path) = parse_lit_into_path(cx, CRATE, &m.lit) {
-                        serde_path.set(&m.path, path)
+                        serde_path.set(&m.path, path);
+                    }
+                }
+
+                // Parse `#[serde(expecting = "a message")]`
+                Meta(NameValue(m)) if m.path == EXPECTING => {
+                    if let Ok(s) = get_lit_str(cx, EXPECTING, &m.lit) {
+                        expecting.set(&m.path, s.value());
                    }
                }

@@ -581,21 +552,20 @@ impl Container {
                        .into_token_stream()
                        .to_string()
                        .replace(' ', "");
-                    cx.error_spanned_by(
-                        meta_item.path(),
-                        format!("unknown serde container attribute `{}`", path),
-                    );
+                    let msg = format!("unknown serde container attribute `{}`", path);
+                    cx.error_spanned_by(meta_item.path(), msg);
                }

                Lit(lit) => {
-                    cx.error_spanned_by(lit, "unexpected literal in serde container attribute");
+                    let msg = "unexpected literal in serde container attribute";
+                    cx.error_spanned_by(lit, msg);
                }
            }
        }

        let mut is_packed = false;
        for attr in &item.attrs {
-            if attr.path.is_ident("repr") {
+            if attr.path == REPR {
                let _ = attr.parse_args_with(|input: ParseStream| {
                    while let Some(token) = input.parse()? {
                        if let TokenTree::Ident(ident) = token {
@@ -627,6 +597,7 @@ impl Container {
            has_flatten: false,
            serde_path: serde_path.get(),
            is_packed,
+            expecting: expecting.get(),
        }
    }

@@ -702,6 +673,12 @@ impl Container {
        self.custom_serde_path()
            .map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
    }
+
+    /// Error message generated when type can't be deserialized.
+    /// If `None`, default message will be used
+    pub fn expecting(&self) -> Option<&str> {
+        self.expecting.as_ref().map(String::as_ref)
+    }
 }

 fn decide_tag(
@@ -726,10 +703,9 @@ fn decide_tag(
                        syn::Fields::Named(_) | syn::Fields::Unit => {}
                        syn::Fields::Unnamed(fields) => {
                            if fields.unnamed.len() != 1 {
-                                cx.error_spanned_by(
-                                    variant,
-                                    "#[serde(tag = \"...\")] cannot be used with tuple variants",
-                                );
+                                let msg =
+                                    "#[serde(tag = \"...\")] cannot be used with tuple variants";
+                                cx.error_spanned_by(variant, msg);
                                break;
                            }
                        }
@@ -739,48 +715,28 @@ fn decide_tag(
            TagType::Internal { tag }
        }
        (Some((untagged_tokens, _)), Some((tag_tokens, _)), None) => {
-            cx.error_spanned_by(
-                untagged_tokens,
-                "enum cannot be both untagged and internally tagged",
-            );
-            cx.error_spanned_by(
-                tag_tokens,
-                "enum cannot be both untagged and internally tagged",
-            );
+            let msg = "enum cannot be both untagged and internally tagged";
+            cx.error_spanned_by(untagged_tokens, msg);
+            cx.error_spanned_by(tag_tokens, msg);
            TagType::External // doesn't matter, will error
        }
        (None, None, Some((content_tokens, _))) => {
-            cx.error_spanned_by(
-                content_tokens,
-                "#[serde(tag = \"...\", content = \"...\")] must be used together",
-            );
+            let msg = "#[serde(tag = \"...\", content = \"...\")] must be used together";
+            cx.error_spanned_by(content_tokens, msg);
            TagType::External
        }
        (Some((untagged_tokens, _)), None, Some((content_tokens, _))) => {
-            cx.error_spanned_by(
-                untagged_tokens,
-                "untagged enum cannot have #[serde(content = \"...\")]",
-            );
-            cx.error_spanned_by(
-                content_tokens,
-                "untagged enum cannot have #[serde(content = \"...\")]",
-            );
+            let msg = "untagged enum cannot have #[serde(content = \"...\")]";
+            cx.error_spanned_by(untagged_tokens, msg);
+            cx.error_spanned_by(content_tokens, msg);
            TagType::External
        }
        (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent { tag, content },
        (Some((untagged_tokens, _)), Some((tag_tokens, _)), Some((content_tokens, _))) => {
-            cx.error_spanned_by(
-                untagged_tokens,
-                "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
-            );
-            cx.error_spanned_by(
-                tag_tokens,
-                "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
-            );
-            cx.error_spanned_by(
-                content_tokens,
-                "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
-            );
+            let msg = "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]";
+            cx.error_spanned_by(untagged_tokens, msg);
+            cx.error_spanned_by(tag_tokens, msg);
+            cx.error_spanned_by(content_tokens, msg);
            TagType::External
        }
    }
@@ -799,44 +755,32 @@ fn decide_identifier(
    ) {
        (_, None, None) => Identifier::No,
        (_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => {
-            cx.error_spanned_by(
-                field_identifier_tokens,
-                "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set",
-            );
-            cx.error_spanned_by(
-                variant_identifier_tokens,
-                "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set",
-            );
+            let msg =
+                "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set";
+            cx.error_spanned_by(field_identifier_tokens, msg);
+            cx.error_spanned_by(variant_identifier_tokens, msg);
            Identifier::No
        }
        (syn::Data::Enum(_), Some(_), None) => Identifier::Field,
        (syn::Data::Enum(_), None, Some(_)) => Identifier::Variant,
        (syn::Data::Struct(syn::DataStruct { struct_token, .. }), Some(_), None) => {
-            cx.error_spanned_by(
-                struct_token,
-                "#[serde(field_identifier)] can only be used on an enum",
-            );
+            let msg = "#[serde(field_identifier)] can only be used on an enum";
+            cx.error_spanned_by(struct_token, msg);
            Identifier::No
        }
        (syn::Data::Union(syn::DataUnion { union_token, .. }), Some(_), None) => {
-            cx.error_spanned_by(
-                union_token,
-                "#[serde(field_identifier)] can only be used on an enum",
-            );
+            let msg = "#[serde(field_identifier)] can only be used on an enum";
+            cx.error_spanned_by(union_token, msg);
            Identifier::No
        }
        (syn::Data::Struct(syn::DataStruct { struct_token, .. }), None, Some(_)) => {
-            cx.error_spanned_by(
-                struct_token,
-                "#[serde(variant_identifier)] can only be used on an enum",
-            );
+            let msg = "#[serde(variant_identifier)] can only be used on an enum";
+            cx.error_spanned_by(struct_token, msg);
            Identifier::No
        }
        (syn::Data::Union(syn::DataUnion { union_token, .. }), None, Some(_)) => {
-            cx.error_spanned_by(
-                union_token,
-                "#[serde(variant_identifier)] can only be used on an enum",
-            );
+            let msg = "#[serde(variant_identifier)] can only be used on an enum";
+            cx.error_spanned_by(union_token, msg);
            Identifier::No
        }
    }
@@ -853,7 +797,12 @@ pub struct Variant {
    other: bool,
    serialize_with: Option<syn::ExprPath>,
    deserialize_with: Option<syn::ExprPath>,
-    borrow: Option<syn::Meta>,
+    borrow: Option<BorrowAttribute>,
+}
+
+struct BorrowAttribute {
+    path: syn::Path,
+    lifetimes: Option<BTreeSet<syn::Lifetime>>,
 }

 impl Variant {
@@ -914,13 +863,7 @@ impl Variant {
                                rename_all_ser_rule.set(&m.path, rename_rule);
                                rename_all_de_rule.set(&m.path, rename_rule);
                            }
-                            Err(()) => cx.error_spanned_by(
-                                s,
-                                format!(
-                                    "unknown rename rule for #[serde(rename_all = {:?})]",
-                                    s.value()
-                                ),
-                            ),
+                            Err(err) => cx.error_spanned_by(s, err),
                        }
                    }
                }
@@ -931,25 +874,13 @@ impl Variant {
                        if let Some(ser) = ser {
                            match RenameRule::from_str(&ser.value()) {
                                Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    ser,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        ser.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(ser, err),
                            }
                        }
                        if let Some(de) = de {
                            match RenameRule::from_str(&de.value()) {
                                Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    de,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        de.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(de, err),
                            }
                        }
                    }
@@ -1024,16 +955,39 @@ impl Variant {
                    }
                }

-                // Defer `#[serde(borrow)]` and `#[serde(borrow = "'a + 'b")]`
-                Meta(m) if m.path() == BORROW => match &variant.fields {
+                // Parse `#[serde(borrow)]`
+                Meta(Path(word)) if word == BORROW => match &variant.fields {
                    syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
-                        borrow.set(m.path(), m.clone());
+                        borrow.set(
+                            word,
+                            BorrowAttribute {
+                                path: word.clone(),
+                                lifetimes: None,
+                            },
+                        );
                    }
                    _ => {
-                        cx.error_spanned_by(
-                            variant,
-                            "#[serde(borrow)] may only be used on newtype variants",
-                        );
+                        let msg = "#[serde(borrow)] may only be used on newtype variants";
+                        cx.error_spanned_by(variant, msg);
+                    }
+                },
+
+                // Parse `#[serde(borrow = "'a + 'b")]`
+                Meta(NameValue(m)) if m.path == BORROW => match &variant.fields {
+                    syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
+                        if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, &m.lit) {
+                            borrow.set(
+                                &m.path,
+                                BorrowAttribute {
+                                    path: m.path.clone(),
+                                    lifetimes: Some(lifetimes),
+                                },
+                            );
+                        }
+                    }
+                    _ => {
+                        let msg = "#[serde(borrow)] may only be used on newtype variants";
+                        cx.error_spanned_by(variant, msg);
                    }
                },

@@ -1043,14 +997,13 @@ impl Variant {
                        .into_token_stream()
                        .to_string()
                        .replace(' ', "");
-                    cx.error_spanned_by(
-                        meta_item.path(),
-                        format!("unknown serde variant attribute `{}`", path),
-                    );
+                    let msg = format!("unknown serde variant attribute `{}`", path);
+                    cx.error_spanned_by(meta_item.path(), msg);
                }

                Lit(lit) => {
-                    cx.error_spanned_by(lit, "unexpected literal in serde variant attribute");
+                    let msg = "unexpected literal in serde variant attribute";
+                    cx.error_spanned_by(lit, msg);
                }
            }
        }
@@ -1187,16 +1140,28 @@ impl Field {
            None => index.to_string(),
        };

-        let variant_borrow = attrs
-            .and_then(|variant| variant.borrow.as_ref())
-            .map(|borrow| Meta(borrow.clone()));
+        if let Some(borrow_attribute) = attrs.and_then(|variant| variant.borrow.as_ref()) {
+            if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
+                if let Some(lifetimes) = &borrow_attribute.lifetimes {
+                    for lifetime in lifetimes {
+                        if !borrowable.contains(lifetime) {
+                            let msg =
+                                format!("field `{}` does not have lifetime {}", ident, lifetime);
+                            cx.error_spanned_by(field, msg);
+                        }
+                    }
+                    borrowed_lifetimes.set(&borrow_attribute.path, lifetimes.clone());
+                } else {
+                    borrowed_lifetimes.set(&borrow_attribute.path, borrowable);
+                }
+            }
+        }

        for meta_item in field
            .attrs
            .iter()
            .flat_map(|attr| get_serde_meta_items(cx, attr))
            .flatten()
-            .chain(variant_borrow)
        {
            match &meta_item {
                // Parse `#[serde(rename = "foo")]`
@@ -1318,17 +1283,15 @@ impl Field {

                // Parse `#[serde(borrow = "'a + 'b")]`
                Meta(NameValue(m)) if m.path == BORROW => {
-                    if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, BORROW, &m.lit) {
+                    if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, &m.lit) {
                        if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
                            for lifetime in &lifetimes {
                                if !borrowable.contains(lifetime) {
-                                    cx.error_spanned_by(
-                                        field,
-                                        format!(
-                                            "field `{}` does not have lifetime {}",
-                                            ident, lifetime
-                                        ),
+                                    let msg = format!(
+                                        "field `{}` does not have lifetime {}",
+                                        ident, lifetime,
                                    );
+                                    cx.error_spanned_by(field, msg);
                                }
                            }
                            borrowed_lifetimes.set(&m.path, lifetimes);
@@ -1354,14 +1317,13 @@ impl Field {
                        .into_token_stream()
                        .to_string()
                        .replace(' ', "");
-                    cx.error_spanned_by(
-                        meta_item.path(),
-                        format!("unknown serde field attribute `{}`", path),
-                    );
+                    let msg = format!("unknown serde field attribute `{}`", path);
+                    cx.error_spanned_by(meta_item.path(), msg);
                }

                Lit(lit) => {
-                    cx.error_spanned_by(lit, "unexpected literal in serde field attribute");
+                    let msg = "unexpected literal in serde field attribute";
+                    cx.error_spanned_by(lit, msg);
                }
            }
        }
@@ -1393,7 +1355,7 @@ impl Field {
                };
                let span = Span::call_site();
                path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("private", span).into());
+                path.segments.push(Ident::new("__private", span).into());
                path.segments.push(Ident::new("de", span).into());
                path.segments
                    .push(Ident::new("borrow_cow_str", span).into());
@@ -1410,7 +1372,7 @@ impl Field {
                };
                let span = Span::call_site();
                path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("private", span).into());
+                path.segments.push(Ident::new("__private", span).into());
                path.segments.push(Ident::new("de", span).into());
                path.segments
                    .push(Ident::new("borrow_cow_bytes", span).into());
@@ -1544,13 +1506,11 @@ where
            }

            _ => {
-                cx.error_spanned_by(
-                    meta,
-                    format!(
-                        "malformed {0} attribute, expected `{0}(serialize = ..., deserialize = ...)`",
-                        attr_name
-                    ),
+                let msg = format!(
+                    "malformed {0} attribute, expected `{0}(serialize = ..., deserialize = ...)`",
+                    attr_name,
                );
+                cx.error_spanned_by(meta, msg);
                return Err(());
            }
        }
@@ -1614,21 +1574,20 @@ fn get_lit_str2<'a>(
    if let syn::Lit::Str(lit) = lit {
        Ok(lit)
    } else {
-        cx.error_spanned_by(
-            lit,
-            format!(
-                "expected serde {} attribute to be a string: `{} = \"...\"`",
-                attr_name, meta_item_name
-            ),
+        let msg = format!(
+            "expected serde {} attribute to be a string: `{} = \"...\"`",
+            attr_name, meta_item_name,
        );
+        cx.error_spanned_by(lit, msg);
        Err(())
    }
 }

 fn parse_lit_into_path(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Path, ()> {
    let string = get_lit_str(cx, attr_name, lit)?;
-    parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
+    string.parse().map_err(|_| {
+        let msg = format!("failed to parse path: {:?}", string.value());
+        cx.error_spanned_by(lit, msg);
    })
 }

@@ -1638,8 +1597,9 @@ fn parse_lit_into_expr_path(
    lit: &syn::Lit,
 ) -> Result<syn::ExprPath, ()> {
    let string = get_lit_str(cx, attr_name, lit)?;
-    parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()))
+    string.parse().map_err(|_| {
+        let msg = format!("failed to parse path: {:?}", string.value());
+        cx.error_spanned_by(lit, msg);
    })
 }

@@ -1650,63 +1610,53 @@ fn parse_lit_into_where(
    lit: &syn::Lit,
 ) -> Result<Vec<syn::WherePredicate>, ()> {
    let string = get_lit_str2(cx, attr_name, meta_item_name, lit)?;
-    if string.value().is_empty() {
-        return Ok(Vec::new());
-    }

-    let where_string = syn::LitStr::new(&format!("where {}", string.value()), string.span());
-
-    parse_lit_str::<syn::WhereClause>(&where_string)
-        .map(|wh| wh.predicates.into_iter().collect())
+    string
+        .parse_with(Punctuated::<syn::WherePredicate, Token![,]>::parse_terminated)
+        .map(Vec::from_iter)
        .map_err(|err| cx.error_spanned_by(lit, err))
 }

 fn parse_lit_into_ty(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Type, ()> {
    let string = get_lit_str(cx, attr_name, lit)?;

-    parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(
-            lit,
-            format!("failed to parse type: {} = {:?}", attr_name, string.value()),
-        )
+    string.parse().map_err(|_| {
+        let msg = format!("failed to parse type: {} = {:?}", attr_name, string.value());
+        cx.error_spanned_by(lit, msg);
    })
 }

 // Parses a string literal like "'a + 'b + 'c" containing a nonempty list of
 // lifetimes separated by `+`.
-fn parse_lit_into_lifetimes(
-    cx: &Ctxt,
-    attr_name: Symbol,
-    lit: &syn::Lit,
-) -> Result<BTreeSet<syn::Lifetime>, ()> {
-    let string = get_lit_str(cx, attr_name, lit)?;
-    if string.value().is_empty() {
-        cx.error_spanned_by(lit, "at least one lifetime must be borrowed");
-        return Err(());
-    }
+fn parse_lit_into_lifetimes(cx: &Ctxt, lit: &syn::Lit) -> Result<BTreeSet<syn::Lifetime>, ()> {
+    let string = get_lit_str(cx, BORROW, lit)?;

-    struct BorrowedLifetimes(Punctuated<syn::Lifetime, Token![+]>);
-
-    impl Parse for BorrowedLifetimes {
-        fn parse(input: ParseStream) -> parse::Result<Self> {
-            Punctuated::parse_separated_nonempty(input).map(BorrowedLifetimes)
-        }
-    }
-
-    if let Ok(BorrowedLifetimes(lifetimes)) = parse_lit_str(string) {
+    if let Ok(lifetimes) = string.parse_with(|input: ParseStream| {
        let mut set = BTreeSet::new();
-        for lifetime in lifetimes {
+        while !input.is_empty() {
+            let lifetime: Lifetime = input.parse()?;
            if !set.insert(lifetime.clone()) {
-                cx.error_spanned_by(lit, format!("duplicate borrowed lifetime `{}`", lifetime));
+                let msg = format!("duplicate borrowed lifetime `{}`", lifetime);
+                cx.error_spanned_by(lit, msg);
            }
+            if input.is_empty() {
+                break;
+            }
+            input.parse::<Token![+]>()?;
        }
-        return Ok(set);
+        Ok(set)
+    }) {
+        return if lifetimes.is_empty() {
+            let msg = "at least one lifetime must be borrowed";
+            cx.error_spanned_by(lit, msg);
+            Err(())
+        } else {
+            Ok(lifetimes)
+        };
    }

-    cx.error_spanned_by(
-        lit,
-        format!("failed to parse borrowed lifetimes: {:?}", string.value()),
-    );
+    let msg = format!("failed to parse borrowed lifetimes: {:?}", string.value());
+    cx.error_spanned_by(lit, msg);
    Err(())
 }

@@ -1861,10 +1811,8 @@ fn borrowable_lifetimes(
    let mut lifetimes = BTreeSet::new();
    collect_lifetimes(&field.ty, &mut lifetimes);
    if lifetimes.is_empty() {
-        cx.error_spanned_by(
-            field,
-            format!("field `{}` has no lifetimes to borrow", name),
-        );
+        let msg = format!("field `{}` has no lifetimes to borrow", name);
+        cx.error_spanned_by(field, msg);
        Err(())
    } else {
        Ok(lifetimes)
@@ -1921,41 +1869,38 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
        syn::Type::Group(ty) => {
            collect_lifetimes(&ty.elem, out);
        }
+        syn::Type::Macro(ty) => {
+            collect_lifetimes_from_tokens(ty.mac.tokens.clone(), out);
+        }
        syn::Type::BareFn(_)
        | syn::Type::Never(_)
        | syn::Type::TraitObject(_)
        | syn::Type::ImplTrait(_)
        | syn::Type::Infer(_)
-        | syn::Type::Macro(_)
-        | syn::Type::Verbatim(_)
-        | _ => {}
+        | syn::Type::Verbatim(_) => {}
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => {}
    }
 }

-fn parse_lit_str<T>(s: &syn::LitStr) -> parse::Result<T>
-where
-    T: Parse,
-{
-    let tokens = spanned_tokens(s)?;
-    syn::parse2(tokens)
-}
-
-fn spanned_tokens(s: &syn::LitStr) -> parse::Result<TokenStream> {
-    let stream = syn::parse_str(&s.value())?;
-    Ok(respan_token_stream(stream, s.span()))
-}
-
-fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
-    stream
-        .into_iter()
-        .map(|token| respan_token_tree(token, span))
-        .collect()
-}
-
-fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
-    if let TokenTree::Group(g) = &mut token {
-        *g = Group::new(g.delimiter(), respan_token_stream(g.stream(), span));
+fn collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet<syn::Lifetime>) {
+    let mut iter = tokens.into_iter();
+    while let Some(tt) = iter.next() {
+        match &tt {
+            TokenTree::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
+                if let Some(TokenTree::Ident(ident)) = iter.next() {
+                    out.insert(syn::Lifetime {
+                        apostrophe: op.span(),
+                        ident,
+                    });
+                }
+            }
+            TokenTree::Group(group) => {
+                let tokens = group.stream();
+                collect_lifetimes_from_tokens(tokens, out);
+            }
+            _ => {}
+        }
    }
-    token.set_span(span);
-    token
 }
@@ -5,7 +5,7 @@
 #[allow(deprecated, unused_imports)]
 use std::ascii::AsciiExt;

-use std::str::FromStr;
+use std::fmt::{self, Debug, Display};

 use self::RenameRule::*;

@@ -17,7 +17,7 @@ pub enum RenameRule {
    /// Rename direct children to "lowercase" style.
    LowerCase,
    /// Rename direct children to "UPPERCASE" style.
-    UPPERCASE,
+    UpperCase,
    /// Rename direct children to "PascalCase" style, as typically used for
    /// enum variants.
    PascalCase,
@@ -35,13 +35,35 @@ pub enum RenameRule {
    ScreamingKebabCase,
 }

+static RENAME_RULES: &[(&str, RenameRule)] = &[
+    ("lowercase", LowerCase),
+    ("UPPERCASE", UpperCase),
+    ("PascalCase", PascalCase),
+    ("camelCase", CamelCase),
+    ("snake_case", SnakeCase),
+    ("SCREAMING_SNAKE_CASE", ScreamingSnakeCase),
+    ("kebab-case", KebabCase),
+    ("SCREAMING-KEBAB-CASE", ScreamingKebabCase),
+];
+
 impl RenameRule {
+    pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError> {
+        for (name, rule) in RENAME_RULES {
+            if rename_all_str == *name {
+                return Ok(*rule);
+            }
+        }
+        Err(ParseError {
+            unknown: rename_all_str,
+        })
+    }
+
    /// Apply a renaming rule to an enum variant, returning the version expected in the source.
    pub fn apply_to_variant(&self, variant: &str) -> String {
        match *self {
            None | PascalCase => variant.to_owned(),
            LowerCase => variant.to_ascii_lowercase(),
-            UPPERCASE => variant.to_ascii_uppercase(),
+            UpperCase => variant.to_ascii_uppercase(),
            CamelCase => variant[..1].to_ascii_lowercase() + &variant[1..],
            SnakeCase => {
                let mut snake = String::new();
@@ -65,7 +87,7 @@ impl RenameRule {
    pub fn apply_to_field(&self, field: &str) -> String {
        match *self {
            None | LowerCase | SnakeCase => field.to_owned(),
-            UPPERCASE => field.to_ascii_uppercase(),
+            UpperCase => field.to_ascii_uppercase(),
            PascalCase => {
                let mut pascal = String::new();
                let mut capitalize = true;
@@ -92,21 +114,22 @@ impl RenameRule {
    }
 }

-impl FromStr for RenameRule {
-    type Err = ();
+pub struct ParseError<'a> {
+    unknown: &'a str,
+}

-    fn from_str(rename_all_str: &str) -> Result<Self, Self::Err> {
-        match rename_all_str {
-            "lowercase" => Ok(LowerCase),
-            "UPPERCASE" => Ok(UPPERCASE),
-            "PascalCase" => Ok(PascalCase),
-            "camelCase" => Ok(CamelCase),
-            "snake_case" => Ok(SnakeCase),
-            "SCREAMING_SNAKE_CASE" => Ok(ScreamingSnakeCase),
-            "kebab-case" => Ok(KebabCase),
-            "SCREAMING-KEBAB-CASE" => Ok(ScreamingKebabCase),
-            _ => Err(()),
+impl<'a> Display for ParseError<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("unknown rename rule `rename_all = ")?;
+        Debug::fmt(self.unknown, f)?;
+        f.write_str("`, expected one of ")?;
+        for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() {
+            if i > 0 {
+                f.write_str(", ")?;
+            }
+            Debug::fmt(name, f)?;
        }
+        Ok(())
    }
 }

@@ -131,7 +154,7 @@ fn rename_variants() {
    ] {
        assert_eq!(None.apply_to_variant(original), original);
        assert_eq!(LowerCase.apply_to_variant(original), lower);
-        assert_eq!(UPPERCASE.apply_to_variant(original), upper);
+        assert_eq!(UpperCase.apply_to_variant(original), upper);
        assert_eq!(PascalCase.apply_to_variant(original), original);
        assert_eq!(CamelCase.apply_to_variant(original), camel);
        assert_eq!(SnakeCase.apply_to_variant(original), snake);
@@ -163,7 +186,7 @@ fn rename_fields() {
        ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"),
    ] {
        assert_eq!(None.apply_to_field(original), original);
-        assert_eq!(UPPERCASE.apply_to_field(original), upper);
+        assert_eq!(UpperCase.apply_to_field(original), upper);
        assert_eq!(PascalCase.apply_to_field(original), pascal);
        assert_eq!(CamelCase.apply_to_field(original), camel);
        assert_eq!(SnakeCase.apply_to_field(original), original);
@@ -6,6 +6,7 @@ use syn::{Member, Type};
 /// Cross-cutting checks that require looking at more than a single attrs
 /// object. Simpler checks should happen when parsing and building the attrs.
 pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
+    check_remote_generic(cx, cont);
    check_getter(cx, cont);
    check_flatten(cx, cont);
    check_identifier(cx, cont);
@@ -16,6 +17,28 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
    check_from_and_try_from(cx, cont);
 }

+/// Remote derive definition type must have either all of the generics of the
+/// remote type:
+///
+///     #[serde(remote = "Generic")]
+///     struct Generic<T> {…}
+///
+/// or none of them, i.e. defining impls for one concrete instantiation of the
+/// remote type only:
+///
+///     #[serde(remote = "Generic<T>")]
+///     struct ConcreteDef {…}
+///
+fn check_remote_generic(cx: &Ctxt, cont: &Container) {
+    if let Some(remote) = cont.attrs.remote() {
+        let local_has_generic = !cont.generics.params.is_empty();
+        let remote_has_generic = !remote.segments.last().unwrap().arguments.is_none();
+        if local_has_generic && remote_has_generic {
+            cx.error_spanned_by(remote, "remove generic parameters from this path");
+        }
+    }
+}
+
 /// Getters are only allowed inside structs (not enums) with the `remote`
 /// attribute.
 fn check_getter(cx: &Ctxt, cont: &Container) {
@@ -260,7 +283,7 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
        cx.error_spanned_by(
            cont.original,
            format!("variant field name `{}` conflicts with internal tag", tag),
-        )
+        );
    };

    for variant in variants {
@@ -396,7 +419,7 @@ fn member_message(member: &Member) -> String {
 }

 fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ty) = ungroup(&field.ty) {
+    if let Type::Path(ty) = ungroup(field.ty) {
        if let Some(seg) = ty.path.segments.last() {
            if seg.ident == "PhantomData" {
                return false;
@@ -4,8 +4,12 @@ pub mod attr;
 mod ctxt;
 pub use self::ctxt::Ctxt;

+mod receiver;
+pub use self::receiver::replace_receiver;
+
 mod case;
 mod check;
+mod respan;
 mod symbol;

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

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.117")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.156")]
 #![allow(unknown_lints, bare_trait_objects)]
-#![deny(clippy::all, clippy::pedantic)]
 // Ignored clippy lints
 #![allow(
+    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
+    clippy::branches_sharing_code,
    clippy::cognitive_complexity,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
+    clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
    clippy::enum_variant_names,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
+    clippy::manual_map,
    clippy::match_like_matches_macro,
    clippy::needless_pass_by_value,
    clippy::too_many_arguments,
@@ -35,11 +41,14 @@
    clippy::checked_conversions,
    clippy::doc_markdown,
    clippy::enum_glob_use,
-    clippy::filter_map,
    clippy::indexing_slicing,
    clippy::items_after_statements,
+    clippy::let_underscore_untyped,
+    clippy::manual_assert,
    clippy::map_err_ignore,
    clippy::match_same_arms,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
+    clippy::match_wildcard_for_single_variants,
    clippy::module_name_repetitions,
    clippy::must_use_candidate,
    clippy::option_if_let_else,
@@ -48,9 +57,11 @@
    clippy::struct_excessive_bools,
    clippy::too_many_lines,
    clippy::unseparated_literal_suffix,
+    clippy::unused_self,
    clippy::use_self,
    clippy::wildcard_imports
 )]
+#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]

 #[macro_use]
 extern crate quote;
@@ -74,20 +85,21 @@ 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 input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&input)
+    let mut input = parse_macro_input!(input as DeriveInput);
+    ser::expand_derive_serialize(&mut input)
        .unwrap_or_else(to_compile_errors)
        .into()
 }

 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&input)
+    let mut input = parse_macro_input!(input as DeriveInput);
+    de::expand_derive_deserialize(&mut input)
        .unwrap_or_else(to_compile_errors)
        .into()
 }
@@ -1,7 +1,7 @@
-use proc_macro2::{Span, TokenStream};
-use syn::Ident;
+use proc_macro2::TokenStream;
+use quote::format_ident;

-use internals::ast::{Container, Data, Field, Style};
+use internals::ast::{Container, Data, Field, Style, Variant};

 // Suppress dead_code warnings that would otherwise appear when using a remote
 // derive. Other than this pretend code, a struct annotated with remote derive
@@ -20,8 +20,8 @@ use internals::ast::{Container, Data, Field, Style};
 //     8 | enum EnumDef { V }
 //       |                ^
 //
-pub fn pretend_used(cont: &Container) -> TokenStream {
-    let pretend_fields = pretend_fields_used(cont);
+pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
+    let pretend_fields = pretend_fields_used(cont, is_packed);
    let pretend_variants = pretend_variants_used(cont);

    quote! {
@@ -32,51 +32,119 @@ pub fn pretend_used(cont: &Container) -> TokenStream {

 // For structs with named fields, expands to:
 //
+//     match None::<&T> {
+//         Some(T { a: __v0, b: __v1 }) => {}
+//         _ => {}
+//     }
+//
+// For packed structs on sufficiently new rustc, expands to:
+//
+//     match None::<&T> {
+//         Some(__v @ T { a: _, b: _ }) => {
+//             let _ = addr_of!(__v.a);
+//             let _ = addr_of!(__v.b);
+//         }
+//         _ => {}
+//     }
+//
+// For packed structs on older rustc, we assume Sized and !Drop, and expand to:
+//
 //     match None::<T> {
-//         Some(T { a: ref __v0, b: ref __v1 }) => {}
+//         Some(T { a: __v0, b: __v1 }) => {}
 //         _ => {}
 //     }
 //
 // For enums, expands to the following but only including struct variants:
 //
-//     match None::<T> {
-//         Some(T::A { a: ref __v0 }) => {}
-//         Some(T::B { b: ref __v0 }) => {}
+//     match None::<&T> {
+//         Some(T::A { a: __v0 }) => {}
+//         Some(T::B { b: __v0 }) => {}
 //         _ => {}
 //     }
 //
-// The `ref` is important in case the user has written a Drop impl on their
-// type. Rust does not allow destructuring a struct or enum that has a Drop
-// impl.
-fn pretend_fields_used(cont: &Container) -> TokenStream {
+fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
+    match &cont.data {
+        Data::Enum(variants) => pretend_fields_used_enum(cont, variants),
+        Data::Struct(Style::Struct, fields) => {
+            if is_packed {
+                pretend_fields_used_struct_packed(cont, fields)
+            } else {
+                pretend_fields_used_struct(cont, fields)
+            }
+        }
+        Data::Struct(_, _) => quote!(),
+    }
+}
+
+fn pretend_fields_used_struct(cont: &Container, fields: &[Field]) -> TokenStream {
    let type_ident = &cont.ident;
    let (_, ty_generics, _) = cont.generics.split_for_impl();

-    let patterns = match &cont.data {
-        Data::Enum(variants) => variants
-            .iter()
-            .filter_map(|variant| match variant.style {
-                Style::Struct => {
-                    let variant_ident = &variant.ident;
-                    let pat = struct_pattern(&variant.fields);
-                    Some(quote!(#type_ident::#variant_ident #pat))
-                }
-                _ => None,
-            })
-            .collect::<Vec<_>>(),
-        Data::Struct(Style::Struct, fields) => {
-            let pat = struct_pattern(fields);
-            vec![quote!(#type_ident #pat)]
-        }
-        Data::Struct(_, _) => {
-            return quote!();
-        }
-    };
+    let members = fields.iter().map(|field| &field.member);
+    let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));

    quote! {
-        match _serde::export::None::<#type_ident #ty_generics> {
+        match _serde::__private::None::<&#type_ident #ty_generics> {
+            _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
+            _ => {}
+        }
+    }
+}
+
+fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> TokenStream {
+    let type_ident = &cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+
+    let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();
+
+    #[cfg(not(no_ptr_addr_of))]
+    {
+        quote! {
+            match _serde::__private::None::<&#type_ident #ty_generics> {
+                _serde::__private::Some(__v @ #type_ident { #(#members: _),* }) => {
+                    #(
+                        let _ = _serde::__private::ptr::addr_of!(__v.#members);
+                    )*
+                }
+                _ => {}
+            }
+        }
+    }
+
+    #[cfg(no_ptr_addr_of)]
+    {
+        let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
+
+        quote! {
+            match _serde::__private::None::<#type_ident #ty_generics> {
+                _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
+                _ => {}
+            }
+        }
+    }
+}
+
+fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStream {
+    let type_ident = &cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+
+    let patterns = variants
+        .iter()
+        .filter_map(|variant| match variant.style {
+            Style::Struct => {
+                let variant_ident = &variant.ident;
+                let members = variant.fields.iter().map(|field| &field.member);
+                let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
+                Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
+            }
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+
+    quote! {
+        match _serde::__private::None::<&#type_ident #ty_generics> {
            #(
-                _serde::export::Some(#patterns) => {}
+                _serde::__private::Some(#patterns) => {}
            )*
            _ => {}
        }
@@ -107,7 +175,7 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
    let cases = variants.iter().map(|variant| {
        let variant_ident = &variant.ident;
        let placeholders = &(0..variant.fields.len())
-            .map(|i| Ident::new(&format!("__v{}", i), Span::call_site()))
+            .map(|i| format_ident!("__v{}", i))
            .collect::<Vec<_>>();

        let pat = match variant.style {
@@ -120,8 +188,8 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
        };

        quote! {
-            match _serde::export::None {
-                _serde::export::Some((#(#placeholders,)*)) => {
+            match _serde::__private::None {
+                _serde::__private::Some((#(#placeholders,)*)) => {
                    let _ = #type_ident::#variant_ident #turbofish #pat;
                }
                _ => {}
@@ -131,10 +199,3 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {

    quote!(#(#cases)*)
 }
-
-fn struct_pattern(fields: &[Field]) -> TokenStream {
-    let members = fields.iter().map(|field| &field.member);
-    let placeholders =
-        (0..fields.len()).map(|i| Ident::new(&format!("__v{}", i), Span::call_site()));
-    quote!({ #(#members: ref #placeholders),* })
-}
@@ -6,10 +6,15 @@ use bound;
 use dummy;
 use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt, Derive};
+use internals::{attr, replace_receiver, Ctxt, Derive};
 use pretend;
+use this;
+
+pub fn expand_derive_serialize(
+    input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+    replace_receiver(input);

-pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
    let ctxt = Ctxt::new();
    let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
        Some(cont) => cont,
@@ -26,10 +31,10 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,

    let impl_block = if let Some(remote) = cont.attrs.remote() {
        let vis = &input.vis;
-        let used = pretend::pretend_used(&cont);
+        let used = pretend::pretend_used(&cont, params.is_packed);
        quote! {
            impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
+                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
                where
                    __S: #serde::Serializer,
                {
@@ -42,7 +47,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
        quote! {
            #[automatically_derived]
            impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
+                fn serialize<__S>(&self, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
                where
                    __S: #serde::Serializer,
                {
@@ -78,9 +83,13 @@ struct Parameters {
    self_var: Ident,

    /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
+    /// types (does not include generic parameters) or `some::remote::Path` for
+    /// remote types.
+    this_type: syn::Path,
+
+    /// Same as `this_type` but using `::<T>` for generic parameters for use in
+    /// expression position.
+    this_value: syn::Path,

    /// Generics including any explicit and inferred bounds for the impl.
    generics: syn::Generics,
@@ -101,18 +110,15 @@ impl Parameters {
            Ident::new("self", Span::call_site())
        };

-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
-
+        let this_type = this::this_type(cont);
+        let this_value = this::this_value(cont);
        let is_packed = cont.attrs.is_packed();
-
        let generics = build_generics(cont);

        Parameters {
            self_var,
-            this,
+            this_type,
+            this_value,
            generics,
            is_remote,
            is_packed,
@@ -122,7 +128,7 @@ impl Parameters {
    /// Type name to use in error messages and `&'static str` arguments to
    /// various Serializer methods.
    fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
+        self.this_type.segments.last().unwrap().ident.to_string()
    }
 }

@@ -211,7 +217,7 @@ fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
    let self_var = &params.self_var;
    quote_block! {
        _serde::Serialize::serialize(
-            &_serde::export::Into::<#type_into>::into(_serde::export::Clone::clone(#self_var)),
+            &_serde::__private::Into::<#type_into>::into(_serde::__private::Clone::clone(#self_var)),
            __serializer)
    }
 }
@@ -372,7 +378,7 @@ fn serialize_struct_as_map(
    let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);

    let len = if cattrs.has_flatten() {
-        quote!(_serde::export::None)
+        quote!(_serde::__private::None)
    } else {
        let len = serialized_fields
            .map(|field| match field.attrs.skip_serializing_if() {
@@ -386,7 +392,7 @@ fn serialize_struct_as_map(
                quote!(#tag_field_exists as usize),
                |sum, expr| quote!(#sum + #expr),
            );
-        quote!(_serde::export::Some(#len))
+        quote!(_serde::__private::Some(#len))
    };

    quote_block! {
@@ -423,7 +429,7 @@ fn serialize_variant(
    variant_index: u32,
    cattrs: &attr::Container,
 ) -> TokenStream {
-    let this = &params.this;
+    let this_value = &params.this_value;
    let variant_ident = &variant.ident;

    if variant.attrs.skip_serializing() {
@@ -433,7 +439,7 @@ fn serialize_variant(
            variant_ident
        );
        let skipped_err = quote! {
-            _serde::export::Err(_serde::ser::Error::custom(#skipped_msg))
+            _serde::__private::Err(_serde::ser::Error::custom(#skipped_msg))
        };
        let fields_pat = match variant.style {
            Style::Unit => quote!(),
@@ -441,32 +447,32 @@ fn serialize_variant(
            Style::Struct => quote!({ .. }),
        };
        quote! {
-            #this::#variant_ident #fields_pat => #skipped_err,
+            #this_value::#variant_ident #fields_pat => #skipped_err,
        }
    } else {
        // variant wasn't skipped
        let case = match variant.style {
            Style::Unit => {
                quote! {
-                    #this::#variant_ident
+                    #this_value::#variant_ident
                }
            }
            Style::Newtype => {
                quote! {
-                    #this::#variant_ident(ref __field0)
+                    #this_value::#variant_ident(ref __field0)
                }
            }
            Style::Tuple => {
                let field_names = (0..variant.fields.len())
                    .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                quote! {
-                    #this::#variant_ident(#(ref #field_names),*)
+                    #this_value::#variant_ident(#(ref #field_names),*)
                }
            }
            Style::Struct => {
                let members = variant.fields.iter().map(|f| &f.member);
                quote! {
-                    #this::#variant_ident { #(ref #members),* }
+                    #this_value::#variant_ident { #(ref #members),* }
                }
            }
        };
@@ -578,7 +584,7 @@ fn serialize_internally_tagged_variant(
    if let Some(path) = variant.attrs.serialize_with() {
        let ser = wrap_serialize_variant_with(params, path, variant);
        return quote_expr! {
-            _serde::private::ser::serialize_tagged_newtype(
+            _serde::__private::ser::serialize_tagged_newtype(
                __serializer,
                #enum_ident_str,
                #variant_ident_str,
@@ -607,7 +613,7 @@ fn serialize_internally_tagged_variant(
            }

            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::private::ser::serialize_tagged_newtype);
+            let func = quote_spanned!(span=> _serde::__private::ser::serialize_tagged_newtype);
            quote_expr! {
                #func(
                    __serializer,
@@ -636,7 +642,7 @@ fn serialize_adjacently_tagged_variant(
    tag: &str,
    content: &str,
 ) -> Fragment {
-    let this = &params.this;
+    let this_type = &params.this_type;
    let type_name = cattrs.name().serialize_name();
    let variant_name = variant.attrs.name().serialize_name();

@@ -715,11 +721,11 @@ fn serialize_adjacently_tagged_variant(
    quote_block! {
        struct __AdjacentlyTagged #wrapper_generics #where_clause {
            data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::export::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 {
-            fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
            where
                __S: _serde::Serializer,
            {
@@ -737,7 +743,7 @@ fn serialize_adjacently_tagged_variant(
        try!(_serde::ser::SerializeStruct::serialize_field(
            &mut __struct, #content, &__AdjacentlyTagged {
                data: (#(#fields_ident,)*),
-                phantom: _serde::export::PhantomData::<#this #ty_generics>,
+                phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
            }));
        _serde::ser::SerializeStruct::end(__struct)
    }
@@ -862,8 +868,8 @@ enum StructVariant<'a> {
    Untagged,
 }

-fn serialize_struct_variant<'a>(
-    context: StructVariant<'a>,
+fn serialize_struct_variant(
+    context: StructVariant,
    params: &Parameters,
    fields: &[Field],
    name: &str,
@@ -946,8 +952,8 @@ fn serialize_struct_variant<'a>(
    }
 }

-fn serialize_struct_variant_with_flatten<'a>(
-    context: StructVariant<'a>,
+fn serialize_struct_variant_with_flatten(
+    context: StructVariant,
    params: &Parameters,
    fields: &[Field],
    name: &str,
@@ -967,7 +973,7 @@ fn serialize_struct_variant_with_flatten<'a>(
            variant_index,
            variant_name,
        } => {
-            let this = &params.this;
+            let this_type = &params.this_type;
            let fields_ty = fields.iter().map(|f| &f.ty);
            let members = &fields.iter().map(|f| &f.member).collect::<Vec<_>>();

@@ -978,18 +984,18 @@ fn serialize_struct_variant_with_flatten<'a>(
            quote_block! {
                struct __EnumFlatten #wrapper_generics #where_clause {
                    data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::export::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 {
-                    fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+                    fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
                    where
                        __S: _serde::Serializer,
                    {
                        let (#(#members,)*) = self.data;
                        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                            __serializer,
-                            _serde::export::None));
+                            _serde::__private::None));
                        #(#serialize_fields)*
                        _serde::ser::SerializeMap::end(__serde_state)
                    }
@@ -1002,7 +1008,7 @@ fn serialize_struct_variant_with_flatten<'a>(
                    #variant_name,
                    &__EnumFlatten {
                        data: (#(#members,)*),
-                        phantom: _serde::export::PhantomData::<#this #ty_generics>,
+                        phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
                    })
            }
        }
@@ -1010,7 +1016,7 @@ fn serialize_struct_variant_with_flatten<'a>(
            quote_block! {
                let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                    __serializer,
-                    _serde::export::None));
+                    _serde::__private::None));
                try!(_serde::ser::SerializeMap::serialize_entry(
                    &mut __serde_state,
                    #tag,
@@ -1024,7 +1030,7 @@ fn serialize_struct_variant_with_flatten<'a>(
            quote_block! {
                let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                    __serializer,
-                    _serde::export::None));
+                    _serde::__private::None));
                #(#serialize_fields)*
                _serde::ser::SerializeMap::end(__serde_state)
            }
@@ -1095,7 +1101,7 @@ fn serialize_struct_visitor(
            let mut field_expr = if is_enum {
                quote!(#member)
            } else {
-                get_member(params, field, &member)
+                get_member(params, field, member)
            };

            let key_expr = field.attrs.name().serialize_name();
@@ -1113,7 +1119,7 @@ fn serialize_struct_visitor(
            let ser = if field.attrs.flatten() {
                let func = quote_spanned!(span=> _serde::Serialize::serialize);
                quote! {
-                    try!(#func(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
+                    try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
                }
            } else {
                let func = struct_trait.serialize_field(span);
@@ -1188,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() {
@@ -1208,11 +1214,11 @@ fn wrap_serialize_with(
    quote!({
        struct __SerializeWith #wrapper_impl_generics #where_clause {
            values: (#(&'__a #field_tys, )*),
-            phantom: _serde::export::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 {
-            fn serialize<__S>(&self, __s: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __s: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
            where
                __S: _serde::Serializer,
            {
@@ -1222,7 +1228,7 @@ fn wrap_serialize_with(

        &__SerializeWith {
            values: (#(#field_exprs, )*),
-            phantom: _serde::export::PhantomData::<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
        }
    })
 }
@@ -1258,11 +1264,11 @@ fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStrea
                quote!(&#self_var.#member)
            };
            let ty = field.ty;
-            quote!(_serde::private::ser::constrain::<#ty>(#inner))
+            quote!(_serde::__private::ser::constrain::<#ty>(#inner))
        }
        (true, Some(getter)) => {
            let ty = field.ty;
-            quote!(_serde::private::ser::constrain::<#ty>(&#getter(#self_var)))
+            quote!(_serde::__private::ser::constrain::<#ty>(&#getter(#self_var)))
        }
        (false, Some(_)) => {
            unreachable!("getter is only allowed for remote impls");
@@ -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())
+    }
+}
@@ -13,9 +13,9 @@ pub fn replacement() -> TokenStream {
        macro_rules! try {
            (#dollar __expr:expr) => {
                match #dollar __expr {
-                    _serde::export::Ok(__val) => __val,
-                    _serde::export::Err(__err) => {
-                        return _serde::export::Err(__err);
+                    _serde::__private::Ok(__val) => __val,
+                    _serde::__private::Err(__err) => {
+                        return _serde::__private::Err(__err);
                    }
                }
            }
@@ -0,0 +1 @@
+msrv = "1.31.0"
@@ -1,14 +1,15 @@
 [package]
 name = "serde_derive_internals"
-version = "0.25.0" # remember to update html_root_url
+version = "0.26.0" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT OR Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.rs/serde_derive_internals"
-keywords = ["serde", "serialization"]
+homepage = "https://serde.rs"
 include = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.31"

 [lib]
 path = "lib.rs"
@@ -16,7 +17,7 @@ path = "lib.rs"
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.33", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+syn = { version = "1.0.104", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
@@ -0,0 +1,15 @@
+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
+    // repo.
+    let mod_behind_symlink = Path::new("src/mod.rs");
+    if !mod_behind_symlink.exists() {
+        println!("cargo:rustc-cfg=serde_build_from_git");
+    }
+}
@@ -1,16 +1,40 @@
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.25.0")]
+#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.26.0")]
 #![allow(unknown_lints, bare_trait_objects)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        cognitive_complexity,
-        redundant_field_names,
-        trivially_copy_pass_by_ref,
-        wildcard_in_or_patterns,
-        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-        unnested_or_patterns,
-    )
+// Ignored clippy lints
+#![allow(
+    clippy::cognitive_complexity,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
+    clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
+    clippy::manual_map,
+    clippy::missing_panics_doc,
+    clippy::redundant_field_names,
+    clippy::result_unit_err,
+    clippy::should_implement_trait,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::wildcard_in_or_patterns,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+    clippy::unnested_or_patterns,
+)]
+// Ignored clippy_pedantic lints
+#![allow(
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::items_after_statements,
+    clippy::let_underscore_untyped,
+    clippy::manual_assert,
+    clippy::match_same_arms,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
+    clippy::match_wildcard_for_single_variants,
+    clippy::missing_errors_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::struct_excessive_bools,
+    clippy::too_many_lines,
+    clippy::unused_self,
+    clippy::wildcard_imports
 )]

 #[macro_use]
@@ -19,7 +43,8 @@ extern crate syn;
 extern crate proc_macro2;
 extern crate quote;

-#[path = "src/mod.rs"]
+#[cfg_attr(serde_build_from_git, path = "../serde_derive/src/internals/mod.rs")]
+#[cfg_attr(not(serde_build_from_git), path = "src/mod.rs")]
 mod internals;

 pub use internals::*;
@@ -0,0 +1 @@
+msrv = "1.13.0"
@@ -1,15 +1,18 @@
 [package]
 name = "serde_test"
-version = "1.0.117" # remember to update html_root_url
+version = "1.0.156" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT OR Apache-2.0"
+build = "build.rs"
+categories = ["development-tools::testing"]
 description = "Token De/Serializer for testing De/Serialize implementations"
+documentation = "https://docs.rs/serde_test"
 homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
-documentation = "https://docs.serde.rs/serde_test/"
-keywords = ["serde", "serialization"]
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+keywords = ["serde", "serialization", "testing", "dev-dependencies"]
+license = "MIT OR Apache-2.0"
 readme = "crates-io.md"
-include = ["src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+repository = "https://github.com/serde-rs/serde"
+rust-version = "1.19"

 [dependencies]
 serde = { version = "1.0.60", path = "../serde" }
@@ -18,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"]
@@ -0,0 +1,50 @@
+use std::env;
+use std::process::Command;
+use std::str::{self, FromStr};
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let minor = match rustc_minor_version() {
+        Some(minor) => minor,
+        None => return,
+    };
+
+    // #[track_caller] stabilized in Rust 1.46:
+    // https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html#track_caller
+    if minor < 46 {
+        println!("cargo:rustc-cfg=no_track_caller");
+    }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+    let rustc = match env::var_os("RUSTC") {
+        Some(rustc) => rustc,
+        None => return None,
+    };
+
+    let output = match Command::new(rustc).arg("--version").output() {
+        Ok(output) => output,
+        Err(_) => return None,
+    };
+
+    let version = match str::from_utf8(&output.stdout) {
+        Ok(version) => version,
+        Err(_) => return None,
+    };
+
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    u32::from_str(next).ok()
+}
@@ -28,6 +28,7 @@ use std::fmt::Debug;
 ///     Token::StructEnd,
 /// ]);
 /// ```
+#[cfg_attr(not(no_track_caller), track_caller)]
 pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
    T: Serialize + Deserialize<'de> + PartialEq + Debug,
@@ -58,7 +59,8 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
-pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
+#[cfg_attr(not(no_track_caller), track_caller)]
+pub fn assert_ser_tokens<T: ?Sized>(value: &T, tokens: &[Token])
 where
    T: Serialize,
 {
@@ -110,7 +112,8 @@ where
 ///     assert_ser_tokens_error(&example, expected, error);
 /// }
 /// ```
-pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: &str)
+#[cfg_attr(not(no_track_caller), track_caller)]
+pub fn assert_ser_tokens_error<T: ?Sized>(value: &T, tokens: &[Token], error: &str)
 where
    T: Serialize,
 {
@@ -147,6 +150,7 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
+#[cfg_attr(not(no_track_caller), track_caller)]
 pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
    T: Deserialize<'de> + PartialEq + Debug,
@@ -199,6 +203,7 @@ where
 ///     "unknown field `x`, expected `a` or `b`",
 /// );
 /// ```
+#[cfg_attr(not(no_track_caller), track_caller)]
 pub fn assert_de_tokens_error<'de, T>(tokens: &'de [Token], error: &str)
 where
    T: Deserialize<'de>,
@@ -777,6 +777,17 @@ macro_rules! impl_deserializer {
            {
                self.0.next_value_seed($wrapper(seed))
            }
+            fn next_entry_seed<K, V>(
+                &mut self,
+                kseed: K,
+                vseed: V,
+            ) -> Result<Option<(K::Value, V::Value)>, D::Error>
+            where
+                K: DeserializeSeed<'de>,
+                V: DeserializeSeed<'de>,
+            {
+                self.0.next_entry_seed($wrapper(kseed), $wrapper(vseed))
+            }
            fn size_hint(&self) -> Option<usize> {
                self.0.size_hint()
            }
@@ -168,14 +168,42 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                        self.next_token();
                        visitor.visit_str(variant)
                    }
+                    (Token::BorrowedStr(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_borrowed_str(variant)
+                    }
+                    (Token::String(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_string(variant.to_string())
+                    }
                    (Token::Bytes(variant), Token::Unit) => {
                        self.next_token();
                        visitor.visit_bytes(variant)
                    }
+                    (Token::BorrowedBytes(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_borrowed_bytes(variant)
+                    }
+                    (Token::ByteBuf(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_byte_buf(variant.to_vec())
+                    }
+                    (Token::U8(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_u8(variant)
+                    }
+                    (Token::U16(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_u16(variant)
+                    }
                    (Token::U32(variant), Token::Unit) => {
                        self.next_token();
                        visitor.visit_u32(variant)
                    }
+                    (Token::U64(variant), Token::Unit) => {
+                        self.next_token();
+                        visitor.visit_u64(variant)
+                    }
                    (variant, Token::Unit) => unexpected!(variant),
                    (variant, _) => {
                        visitor.visit_map(EnumMapVisitor::new(self, variant, EnumFormat::Any))
@@ -250,9 +278,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
            {
                visitor.visit_enum(DeserializerEnumVisitor { de: self })
            }
-            _ => {
-                unexpected!(self.next_token());
-            }
+            _ => self.deserialize_any(visitor),
        }
    }

@@ -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,20 +140,25 @@
 //! # }
 //! ```

-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.117")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.156")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
 // Ignored clippy_pedantic lints
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
+        cloned_instead_of_copied,
+        doc_link_with_quotes, // https://github.com/rust-lang/rust-clippy/issues/8961
        empty_line_after_outer_attr,
+        manual_assert,
        missing_docs_in_private_items,
+        missing_panics_doc,
        module_name_repetitions,
        must_use_candidate,
        redundant_field_names,
+        too_many_lines,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
        use_debug,
        use_self
    )
@@ -32,18 +32,18 @@ impl<'a> Serializer<'a> {
 }

 macro_rules! assert_next_token {
-    ($ser:expr, $expected:ident) => {
-        assert_next_token!($ser, stringify!($expected), Token::$expected, true);
-    };
-    ($ser:expr, $expected:ident($v:expr)) => {
+    ($ser:expr, $actual:ident) => {{
+        assert_next_token!($ser, stringify!($actual), Token::$actual, true);
+    }};
+    ($ser:expr, $actual:ident($v:expr)) => {{
        assert_next_token!(
            $ser,
-            format_args!(concat!(stringify!($expected), "({:?})"), $v),
-            Token::$expected(v),
+            format_args!(concat!(stringify!($actual), "({:?})"), $v),
+            Token::$actual(v),
            v == $v
        );
-    };
-    ($ser:expr, $expected:ident { $($k:ident),* }) => {
+    }};
+    ($ser:expr, $actual:ident { $($k:ident),* }) => {{
        let compare = ($($k,)*);
        let field_format = || {
            use std::fmt::Write;
@@ -55,21 +55,21 @@ macro_rules! assert_next_token {
        };
        assert_next_token!(
            $ser,
-            format_args!(concat!(stringify!($expected), " {{ {}}}"), field_format()),
-            Token::$expected { $($k),* },
+            format_args!(concat!(stringify!($actual), " {{ {}}}"), field_format()),
+            Token::$actual { $($k),* },
            ($($k,)*) == compare
        );
-    };
-    ($ser:expr, $expected:expr, $pat:pat, $guard:expr) => {
+    }};
+    ($ser:expr, $actual:expr, $pat:pat, $guard:expr) => {
        match $ser.next_token() {
            Some($pat) if $guard => {}
-            Some(other) => {
+            Some(expected) => {
                panic!("expected Token::{} but serialized as {}",
-                       $expected, other);
+                       expected, $actual);
            }
            None => {
-                panic!("expected Token::{} after end of serialized tokens",
-                       $expected);
+                panic!("expected end of tokens, but {} was serialized",
+                       $actual);
            }
        }
    };
@@ -4,23 +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.1"
-
 [dev-dependencies]
+automod = "1.0"
 fnv = "1.0"
-macrotest = "=1.0.0"
 rustversion = "1.0"
 serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
-trybuild = "1.0"
+trybuild = { version = "1.0.66", features = ["diff"] }
@@ -1,29 +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 has_rustfmt() -> bool {
-    toolchain_find::find_installed_component("rustfmt").is_some()
-}
-
-fn main() {
-    if cfg!(feature = "expandtest") && has_cargo_expand() && has_rustfmt() {
-        println!("cargo:rustc-cfg=expandtest");
-    }
-}
@@ -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

@@ -1,5 +1,7 @@
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
+#[allow(unused_attributes)]
 #[test]
 fn ui() {
    let t = trybuild::TestCases::new();
@@ -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 },
-}
@@ -1,401 +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(rust_2018_idioms, 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::export::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::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeStruct::serialize_field(
-                &mut __serde_state,
-                "phantom",
-                &self.phantom,
-            ) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            _serde::ser::SerializeStruct::end(__serde_state)
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, 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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
-                }
-            }
-            struct __Visitor<'de, T: AssociatedType<X = i32>> {
-                marker: _serde::export::PhantomData<DefaultTyParam<T>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"struct DefaultTyParam with 1 element",
-                            ));
-                        }
-                    };
-                    _serde::export::Ok(DefaultTyParam { phantom: __field0 })
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    let mut __field0: _serde::export::Option<PhantomData<T>> = _serde::export::None;
-                    while let _serde::export::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        }
-                    {
-                        match __key {
-                            __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field(
-                                            "phantom",
-                                        ),
-                                    );
-                                }
-                                __field0 = _serde::export::Some(
-                                    match _serde::de::MapAccess::next_value::<PhantomData<T>>(
-                                        &mut __map,
-                                    ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("phantom")
-                        {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        },
-                    };
-                    _serde::export::Ok(DefaultTyParam { phantom: __field0 })
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["phantom"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DefaultTyParam",
-                FIELDS,
-                __Visitor {
-                    marker: _serde::export::PhantomData::<DefaultTyParam<T>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.phantom),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"struct DefaultTyParam with 1 element",
-                        ));
-                    }
-                    _serde::export::Ok(())
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    let mut __field0: bool = false;
-                    while let _serde::export::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        }
-                    {
-                        match __key {
-                            __Field::__field0 => {
-                                if __field0 {
-                                    return _serde::export::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::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                                __field0 = true;
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if !__field0 {
-                        self.place.phantom = match _serde::private::de::missing_field("phantom") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        };
-                    };
-                    _serde::export::Ok(())
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["phantom"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DefaultTyParam",
-                FIELDS,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -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>,
-}
@@ -1,582 +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(rust_2018_idioms, 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::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field0,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field1,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "x",
-                        x,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "y",
-                        y,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-            }
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, 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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        3u64 => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 4",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "Unit" => _serde::export::Ok(__Field::__field0),
-                        "NewType" => _serde::export::Ok(__Field::__field1),
-                        "Seq" => _serde::export::Ok(__Field::__field2),
-                        "Map" => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"Unit" => _serde::export::Ok(__Field::__field0),
-                        b"NewType" => _serde::export::Ok(__Field::__field1),
-                        b"Seq" => _serde::export::Ok(__Field::__field2),
-                        b"Map" => _serde::export::Ok(__Field::__field3),
-                        _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
-                        }
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::PhantomData<GenericEnum<T, U>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum GenericEnum")
-                }
-                fn visit_enum<__A>(
-                    self,
-                    __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::EnumAccess<'de>,
-                {
-                    match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        (__Field::__field0, __variant) => {
-                            match _serde::de::VariantAccess::unit_variant(__variant) {
-                                _serde::export::Ok(__val) => __val,
-                                _serde::export::Err(__err) => {
-                                    return _serde::export::Err(__err);
-                                }
-                            };
-                            _serde::export::Ok(GenericEnum::Unit)
-                        }
-                        (__Field::__field1, __variant) => _serde::export::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::export::PhantomData<GenericEnum<T, U>>,
-                                lifetime: _serde::export::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::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "tuple variant GenericEnum::Seq",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                                        T,
-                                    >(
-                                        &mut __seq
-                                    ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: 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::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ;
-                                        }
-                                    };
-                                    _serde::export::Ok(GenericEnum::Seq(__field0, __field1))
-                                }
-                            }
-                            _serde::de::VariantAccess::tuple_variant(
-                                __variant,
-                                2usize,
-                                __Visitor {
-                                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::export::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::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "field identifier",
-                                    )
-                                }
-                                fn visit_u64<__E>(
-                                    self,
-                                    __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
-                                        1u64 => _serde::export::Ok(__Field::__field1),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                                            _serde::de::Unexpected::Unsigned(__value),
-                                            &"field index 0 <= i < 2",
-                                        )),
-                                    }
-                                }
-                                fn visit_str<__E>(
-                                    self,
-                                    __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        "x" => _serde::export::Ok(__Field::__field0),
-                                        "y" => _serde::export::Ok(__Field::__field1),
-                                        _ => _serde::export::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_bytes<__E>(
-                                    self,
-                                    __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        b"x" => _serde::export::Ok(__Field::__field0),
-                                        b"y" => _serde::export::Ok(__Field::__field1),
-                                        _ => _serde::export::Ok(__Field::__ignore),
-                                    }
-                                }
-                            }
-                            impl<'de> _serde::Deserialize<'de> for __Field {
-                                #[inline]
-                                fn deserialize<__D>(
-                                    __deserializer: __D,
-                                ) -> _serde::export::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::export::PhantomData<GenericEnum<T, U>>,
-                                lifetime: _serde::export::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::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "struct variant GenericEnum::Map",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                                        T,
-                                    >(
-                                        &mut __seq
-                                    ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: 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::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ;
-                                        }
-                                    };
-                                    _serde::export::Ok(GenericEnum::Map {
-                                        x: __field0,
-                                        y: __field1,
-                                    })
-                                }
-                                #[inline]
-                                fn visit_map<__A>(
-                                    self,
-                                    mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::MapAccess<'de>,
-                                {
-                                    let mut __field0: _serde::export::Option<T> =
-                                        _serde::export::None;
-                                    let mut __field1: _serde::export::Option<U> =
-                                        _serde::export::None;
-                                    while let _serde::export::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
-                                            _serde::export::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
-                                                return _serde::export::Err(__err);
-                                            }
-                                        }
-                                    {
-                                        match __key {
-                                            __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "x" ) ) ;
-                                                }
-                                                __field0 = _serde::export::Some(
-                                                    match _serde::de::MapAccess::next_value::<T>(
-                                                        &mut __map,
-                                                    ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            __Field::__field1 => {
-                                                if _serde::export::Option::is_some(&__field1) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "y" ) ) ;
-                                                }
-                                                __field1 = _serde::export::Some(
-                                                    match _serde::de::MapAccess::next_value::<U>(
-                                                        &mut __map,
-                                                    ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            _ => {
-                                                let _ = match _serde::de::MapAccess::next_value::<
-                                                    _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
-                                                    _serde::export::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
-                                                        return _serde::export::Err(__err);
-                                                    }
-                                                };
-                                            }
-                                        }
-                                    }
-                                    let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("x") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    let __field1 = match __field1 {
-                                        _serde::export::Some(__field1) => __field1,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("y") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    _serde::export::Ok(GenericEnum::Map {
-                                        x: __field0,
-                                        y: __field1,
-                                    })
-                                }
-                            }
-                            const FIELDS: &'static [&'static str] = &["x", "y"];
-                            _serde::de::VariantAccess::struct_variant(
-                                __variant,
-                                FIELDS,
-                                __Visitor {
-                                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::export::PhantomData,
-                                },
-                            )
-                        }
-                    }
-                }
-            }
-            const VARIANTS: &'static [&'static str] = &["Unit", "NewType", "Seq", "Map"];
-            _serde::Deserializer::deserialize_enum(
-                __deserializer,
-                "GenericEnum",
-                VARIANTS,
-                __Visitor {
-                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -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 },
-}
@@ -1,582 +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(rust_2018_idioms, 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::export::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::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            _serde::ser::SerializeStruct::end(__serde_state)
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, 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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::PhantomData<GenericStruct<T>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct GenericStruct")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
-                    {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"struct GenericStruct with 1 element",
-                            ));
-                        }
-                    };
-                    _serde::export::Ok(GenericStruct { x: __field0 })
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    let mut __field0: _serde::export::Option<T> = _serde::export::None;
-                    while let _serde::export::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        }
-                    {
-                        match __key {
-                            __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("x"),
-                                    );
-                                }
-                                __field0 = _serde::export::Some(
-                                    match _serde::de::MapAccess::next_value::<T>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("x") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        },
-                    };
-                    _serde::export::Ok(GenericStruct { x: __field0 })
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["x"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "GenericStruct",
-                FIELDS,
-                __Visitor {
-                    marker: _serde::export::PhantomData::<GenericStruct<T>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 1",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct GenericStruct")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.x),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"struct GenericStruct with 1 element",
-                        ));
-                    }
-                    _serde::export::Ok(())
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    let mut __field0: bool = false;
-                    while let _serde::export::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        }
-                    {
-                        match __key {
-                            __Field::__field0 => {
-                                if __field0 {
-                                    return _serde::export::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::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                                __field0 = true;
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if !__field0 {
-                        self.place.x = match _serde::private::de::missing_field("x") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        };
-                    };
-                    _serde::export::Ok(())
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["x"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "GenericStruct",
-                FIELDS,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
-pub struct GenericNewTypeStruct<T>(T);
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, 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::export::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(rust_2018_idioms, 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::export::Result<Self, __D::Error>
-        where
-            __D: _serde::Deserializer<'de>,
-        {
-            struct __Visitor<'de, T>
-            where
-                T: _serde::Deserialize<'de>,
-            {
-                marker: _serde::export::PhantomData<GenericNewTypeStruct<T>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericNewTypeStruct",
-                    )
-                }
-                #[inline]
-                fn visit_newtype_struct<__E>(
-                    self,
-                    __e: __E,
-                ) -> _serde::export::Result<Self::Value, __E::Error>
-                where
-                    __E: _serde::Deserializer<'de>,
-                {
-                    let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    _serde::export::Ok(GenericNewTypeStruct(__field0))
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
-                    {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
-                                0usize,
-                                &"tuple struct GenericNewTypeStruct with 1 element",
-                            ));
-                        }
-                    };
-                    _serde::export::Ok(GenericNewTypeStruct(__field0))
-                }
-            }
-            _serde::Deserializer::deserialize_newtype_struct(
-                __deserializer,
-                "GenericNewTypeStruct",
-                __Visitor {
-                    marker: _serde::export::PhantomData::<GenericNewTypeStruct<T>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::export::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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericNewTypeStruct",
-                    )
-                }
-                #[inline]
-                fn visit_newtype_struct<__E>(
-                    self,
-                    __e: __E,
-                ) -> _serde::export::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::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"tuple struct GenericNewTypeStruct with 1 element",
-                        ));
-                    }
-                    _serde::export::Ok(())
-                }
-            }
-            _serde::Deserializer::deserialize_newtype_struct(
-                __deserializer,
-                "GenericNewTypeStruct",
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -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);
@@ -1,172 +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(rust_2018_idioms, 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::export::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::export::PhantomData<GenericTupleStruct<T, U>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericTupleStruct",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
-                    {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
-                                1usize,
-                                &"tuple struct GenericTupleStruct with 2 elements",
-                            ));
-                        }
-                    };
-                    _serde::export::Ok(GenericTupleStruct(__field0, __field1))
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "GenericTupleStruct",
-                2usize,
-                __Visitor {
-                    marker: _serde::export::PhantomData::<GenericTupleStruct<T, U>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::export::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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
-                        __formatter,
-                        "tuple struct GenericTupleStruct",
-                    )
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"tuple struct GenericTupleStruct with 2 elements",
-                        ));
-                    }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.1),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            1usize,
-                            &"tuple struct GenericTupleStruct with 2 elements",
-                        ));
-                    }
-                    _serde::export::Ok(())
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "GenericTupleStruct",
-                2usize,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -1,4 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Deserialize)]
-pub struct GenericTupleStruct<T, U>(T, U);
@@ -1,601 +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(rust_2018_idioms, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<'a> _serde::Serialize for Lifetimes<'a> {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-            }
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, 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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        3u64 => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 4",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "LifetimeSeq" => _serde::export::Ok(__Field::__field0),
-                        "NoLifetimeSeq" => _serde::export::Ok(__Field::__field1),
-                        "LifetimeMap" => _serde::export::Ok(__Field::__field2),
-                        "NoLifetimeMap" => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"LifetimeSeq" => _serde::export::Ok(__Field::__field0),
-                        b"NoLifetimeSeq" => _serde::export::Ok(__Field::__field1),
-                        b"LifetimeMap" => _serde::export::Ok(__Field::__field2),
-                        b"NoLifetimeMap" => _serde::export::Ok(__Field::__field3),
-                        _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
-                        }
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
-                }
-            }
-            struct __Visitor<'de, 'a> {
-                marker: _serde::export::PhantomData<Lifetimes<'a>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
-            }
-            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
-                type Value = Lifetimes<'a>;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum Lifetimes")
-                }
-                fn visit_enum<__A>(
-                    self,
-                    __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::EnumAccess<'de>,
-                {
-                    match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        (__Field::__field0, __variant) => _serde::export::Result::map(
-                            _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
-                            Lifetimes::LifetimeSeq,
-                        ),
-                        (__Field::__field1, __variant) => _serde::export::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::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "field identifier",
-                                    )
-                                }
-                                fn visit_u64<__E>(
-                                    self,
-                                    __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                                            _serde::de::Unexpected::Unsigned(__value),
-                                            &"field index 0 <= i < 1",
-                                        )),
-                                    }
-                                }
-                                fn visit_str<__E>(
-                                    self,
-                                    __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        "a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_bytes<__E>(
-                                    self,
-                                    __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        b"a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
-                                    }
-                                }
-                            }
-                            impl<'de> _serde::Deserialize<'de> for __Field {
-                                #[inline]
-                                fn deserialize<__D>(
-                                    __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
-                                where
-                                    __D: _serde::Deserializer<'de>,
-                                {
-                                    _serde::Deserializer::deserialize_identifier(
-                                        __deserializer,
-                                        __FieldVisitor,
-                                    )
-                                }
-                            }
-                            struct __Visitor<'de, 'a> {
-                                marker: _serde::export::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
-                            }
-                            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
-                                type Value = Lifetimes<'a>;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "struct variant Lifetimes::LifetimeMap",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::export::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::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::LifetimeMap with 1 element" ) ) ;
-                                        }
-                                    };
-                                    _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 })
-                                }
-                                #[inline]
-                                fn visit_map<__A>(
-                                    self,
-                                    mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::MapAccess<'de>,
-                                {
-                                    let mut __field0: _serde::export::Option<&'a i32> =
-                                        _serde::export::None;
-                                    while let _serde::export::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
-                                            _serde::export::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
-                                                return _serde::export::Err(__err);
-                                            }
-                                        }
-                                    {
-                                        match __key {
-                                            __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ;
-                                                }
-                                                __field0 = _serde::export::Some(
-                                                    match _serde::de::MapAccess::next_value::<&'a i32>(
-                                                        &mut __map,
-                                                    ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            _ => {
-                                                let _ = match _serde::de::MapAccess::next_value::<
-                                                    _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
-                                                    _serde::export::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
-                                                        return _serde::export::Err(__err);
-                                                    }
-                                                };
-                                            }
-                                        }
-                                    }
-                                    let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("a") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 })
-                                }
-                            }
-                            const FIELDS: &'static [&'static str] = &["a"];
-                            _serde::de::VariantAccess::struct_variant(
-                                __variant,
-                                FIELDS,
-                                __Visitor {
-                                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::export::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::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "field identifier",
-                                    )
-                                }
-                                fn visit_u64<__E>(
-                                    self,
-                                    __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                                            _serde::de::Unexpected::Unsigned(__value),
-                                            &"field index 0 <= i < 1",
-                                        )),
-                                    }
-                                }
-                                fn visit_str<__E>(
-                                    self,
-                                    __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        "a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
-                                    }
-                                }
-                                fn visit_bytes<__E>(
-                                    self,
-                                    __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
-                                where
-                                    __E: _serde::de::Error,
-                                {
-                                    match __value {
-                                        b"a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
-                                    }
-                                }
-                            }
-                            impl<'de> _serde::Deserialize<'de> for __Field {
-                                #[inline]
-                                fn deserialize<__D>(
-                                    __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
-                                where
-                                    __D: _serde::Deserializer<'de>,
-                                {
-                                    _serde::Deserializer::deserialize_identifier(
-                                        __deserializer,
-                                        __FieldVisitor,
-                                    )
-                                }
-                            }
-                            struct __Visitor<'de, 'a> {
-                                marker: _serde::export::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
-                            }
-                            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
-                                type Value = Lifetimes<'a>;
-                                fn expecting(
-                                    &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
-                                        __formatter,
-                                        "struct variant Lifetimes::NoLifetimeMap",
-                                    )
-                                }
-                                #[inline]
-                                fn visit_seq<__A>(
-                                    self,
-                                    mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::SeqAccess<'de>,
-                                {
-                                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                                        i32,
-                                    >(
-                                        &mut __seq
-                                    ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element" ) ) ;
-                                        }
-                                    };
-                                    _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
-                                }
-                                #[inline]
-                                fn visit_map<__A>(
-                                    self,
-                                    mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
-                                where
-                                    __A: _serde::de::MapAccess<'de>,
-                                {
-                                    let mut __field0: _serde::export::Option<i32> =
-                                        _serde::export::None;
-                                    while let _serde::export::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
-                                            _serde::export::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
-                                                return _serde::export::Err(__err);
-                                            }
-                                        }
-                                    {
-                                        match __key {
-                                            __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ;
-                                                }
-                                                __field0 = _serde::export::Some(
-                                                    match _serde::de::MapAccess::next_value::<i32>(
-                                                        &mut __map,
-                                                    ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
-                                                        }
-                                                    },
-                                                );
-                                            }
-                                            _ => {
-                                                let _ = match _serde::de::MapAccess::next_value::<
-                                                    _serde::de::IgnoredAny,
-                                                >(
-                                                    &mut __map
-                                                ) {
-                                                    _serde::export::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
-                                                        return _serde::export::Err(__err);
-                                                    }
-                                                };
-                                            }
-                                        }
-                                    }
-                                    let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("a") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
-                                                }
-                                            }
-                                        }
-                                    };
-                                    _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
-                                }
-                            }
-                            const FIELDS: &'static [&'static str] = &["a"];
-                            _serde::de::VariantAccess::struct_variant(
-                                __variant,
-                                FIELDS,
-                                __Visitor {
-                                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::export::PhantomData,
-                                },
-                            )
-                        }
-                    }
-                }
-            }
-            const VARIANTS: &'static [&'static str] = &[
-                "LifetimeSeq",
-                "NoLifetimeSeq",
-                "LifetimeMap",
-                "NoLifetimeMap",
-            ];
-            _serde::Deserializer::deserialize_enum(
-                __deserializer,
-                "Lifetimes",
-                VARIANTS,
-                __Visitor {
-                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -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 },
-}
@@ -1,615 +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(rust_2018_idioms, 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::export::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::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::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(rust_2018_idioms, 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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 3",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "a" => _serde::export::Ok(__Field::__field0),
-                        "b" => _serde::export::Ok(__Field::__field1),
-                        "c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"a" => _serde::export::Ok(__Field::__field0),
-                        b"b" => _serde::export::Ok(__Field::__field1),
-                        b"c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::PhantomData<DeNamedMap<A, B, C>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
-                    {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
-                                2usize,
-                                &"struct DeNamedMap with 3 elements",
-                            ));
-                        }
-                    };
-                    _serde::export::Ok(DeNamedMap {
-                        a: __field0,
-                        b: __field1,
-                        c: __field2,
-                    })
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::MapAccess<'de>,
-                {
-                    let mut __field0: _serde::export::Option<A> = _serde::export::None;
-                    let mut __field1: _serde::export::Option<B> = _serde::export::None;
-                    let mut __field2: _serde::export::Option<C> = _serde::export::None;
-                    while let _serde::export::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        }
-                    {
-                        match __key {
-                            __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
-                                    );
-                                }
-                                __field0 = _serde::export::Some(
-                                    match _serde::de::MapAccess::next_value::<A>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            __Field::__field1 => {
-                                if _serde::export::Option::is_some(&__field1) {
-                                    return _serde::export::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("b"),
-                                    );
-                                }
-                                __field1 = _serde::export::Some(
-                                    match _serde::de::MapAccess::next_value::<B>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            __Field::__field2 => {
-                                if _serde::export::Option::is_some(&__field2) {
-                                    return _serde::export::Err(
-                                        <__A::Error as _serde::de::Error>::duplicate_field("c"),
-                                    );
-                                }
-                                __field2 = _serde::export::Some(
-                                    match _serde::de::MapAccess::next_value::<C>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
-                                        }
-                                    },
-                                );
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("a") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        },
-                    };
-                    let __field1 = match __field1 {
-                        _serde::export::Some(__field1) => __field1,
-                        _serde::export::None => match _serde::private::de::missing_field("b") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        },
-                    };
-                    let __field2 = match __field2 {
-                        _serde::export::Some(__field2) => __field2,
-                        _serde::export::None => match _serde::private::de::missing_field("c") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        },
-                    };
-                    _serde::export::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::export::PhantomData::<DeNamedMap<A, B, C>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"field index 0 <= i < 3",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        "a" => _serde::export::Ok(__Field::__field0),
-                        "b" => _serde::export::Ok(__Field::__field1),
-                        "c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        b"a" => _serde::export::Ok(__Field::__field0),
-                        b"b" => _serde::export::Ok(__Field::__field1),
-                        b"c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.a),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"struct DeNamedMap with 3 elements",
-                        ));
-                    }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.b),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            1usize,
-                            &"struct DeNamedMap with 3 elements",
-                        ));
-                    }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.c),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            2usize,
-                            &"struct DeNamedMap with 3 elements",
-                        ));
-                    }
-                    _serde::export::Ok(())
-                }
-                #[inline]
-                fn visit_map<__A>(
-                    self,
-                    mut __map: __A,
-                ) -> _serde::export::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::export::Some(__key) =
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        }
-                    {
-                        match __key {
-                            __Field::__field0 => {
-                                if __field0 {
-                                    return _serde::export::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::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                                __field0 = true;
-                            }
-                            __Field::__field1 => {
-                                if __field1 {
-                                    return _serde::export::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::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                                __field1 = true;
-                            }
-                            __Field::__field2 => {
-                                if __field2 {
-                                    return _serde::export::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::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                                __field2 = true;
-                            }
-                            _ => {
-                                let _ = match _serde::de::MapAccess::next_value::<
-                                    _serde::de::IgnoredAny,
-                                >(&mut __map)
-                                {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    if !__field0 {
-                        self.place.a = match _serde::private::de::missing_field("a") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        };
-                    };
-                    if !__field1 {
-                        self.place.b = match _serde::private::de::missing_field("b") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        };
-                    };
-                    if !__field2 {
-                        self.place.c = match _serde::private::de::missing_field("c") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
-                            }
-                        };
-                    };
-                    _serde::export::Ok(())
-                }
-            }
-            const FIELDS: &'static [&'static str] = &["a", "b", "c"];
-            _serde::Deserializer::deserialize_struct(
-                __deserializer,
-                "DeNamedMap",
-                FIELDS,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -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,
-}
@@ -1,250 +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(rust_2018_idioms, 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::export::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::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
-                }
-            };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::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(rust_2018_idioms, 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::export::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::export::PhantomData<DeNamedTuple<A, B, C>>,
-                lifetime: _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
-                    {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
-                                2usize,
-                                &"tuple struct DeNamedTuple with 3 elements",
-                            ));
-                        }
-                    };
-                    _serde::export::Ok(DeNamedTuple(__field0, __field1, __field2))
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "DeNamedTuple",
-                3usize,
-                __Visitor {
-                    marker: _serde::export::PhantomData::<DeNamedTuple<A, B, C>>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-        fn deserialize_in_place<__D>(
-            __deserializer: __D,
-            __place: &mut Self,
-        ) -> _serde::export::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::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple")
-                }
-                #[inline]
-                fn visit_seq<__A>(
-                    self,
-                    mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<'de>,
-                {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            0usize,
-                            &"tuple struct DeNamedTuple with 3 elements",
-                        ));
-                    }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.1),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            1usize,
-                            &"tuple struct DeNamedTuple with 3 elements",
-                        ));
-                    }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
-                        &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.2),
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
-                            2usize,
-                            &"tuple struct DeNamedTuple with 3 elements",
-                        ));
-                    }
-                    _serde::export::Ok(())
-                }
-            }
-            _serde::Deserializer::deserialize_tuple_struct(
-                __deserializer,
-                "DeNamedTuple",
-                3usize,
-                __Visitor {
-                    place: __place,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -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);
@@ -1,49 +0,0 @@
-use serde::{Deserialize, Serialize};
-struct NamedUnit;
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl _serde::Serialize for NamedUnit {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::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(rust_2018_idioms, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<'de> _serde::Deserialize<'de> for NamedUnit {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "unit struct NamedUnit")
-                }
-                #[inline]
-                fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    _serde::export::Ok(NamedUnit)
-                }
-            }
-            _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor)
-        }
-    }
-};
@@ -1,4 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-struct NamedUnit;
@@ -1,268 +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(rust_2018_idioms, 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::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field0,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field1,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field2,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field3,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "b",
-                        b,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "c",
-                        c,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "d",
-                        d,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field0,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field1,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field2,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeTupleVariant::serialize_field(
-                        &mut __serde_state,
-                        __field3,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::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::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "a",
-                        a,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "b",
-                        b,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "c",
-                        c,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    match _serde::ser::SerializeStructVariant::serialize_field(
-                        &mut __serde_state,
-                        "d",
-                        d,
-                    ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
-                        }
-                    };
-                    _serde::ser::SerializeStructVariant::end(__serde_state)
-                }
-            }
-        }
-    }
-};
@@ -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 },
-}
@@ -1,124 +0,0 @@
-use serde::{Deserialize, Serialize};
-enum Void {}
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl _serde::Serialize for Void {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
-        where
-            __S: _serde::Serializer,
-        {
-            match *self {}
-        }
-    }
-};
-#[doc(hidden)]
-#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _: () = {
-    #[allow(rust_2018_idioms, clippy::useless_attribute)]
-    extern crate serde as _serde;
-    #[automatically_derived]
-    impl<'de> _serde::Deserialize<'de> for Void {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::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::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
-                }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                            _serde::de::Unexpected::Unsigned(__value),
-                            &"variant index 0 <= i < 0",
-                        )),
-                    }
-                }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
-                            __value, VARIANTS,
-                        )),
-                    }
-                }
-                fn visit_bytes<__E>(
-                    self,
-                    __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
-                where
-                    __E: _serde::de::Error,
-                {
-                    match __value {
-                        _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
-                                __value, VARIANTS,
-                            ))
-                        }
-                    }
-                }
-            }
-            impl<'de> _serde::Deserialize<'de> for __Field {
-                #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
-                }
-            }
-            struct __Visitor<'de> {
-                marker: _serde::export::PhantomData<Void>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
-            }
-            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
-                type Value = Void;
-                fn expecting(
-                    &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum Void")
-                }
-                fn visit_enum<__A>(
-                    self,
-                    __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::EnumAccess<'de>,
-                {
-                    _serde::export::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::export::PhantomData::<Void>,
-                    lifetime: _serde::export::PhantomData,
-                },
-            )
-        }
-    }
-};
@@ -1,4 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-enum Void {}
@@ -1,8 +0,0 @@
-#[cfg_attr(target_os = "emscripten", ignore)]
-#[cfg_attr(not(expandtest), ignore)]
-#[rustversion::attr(not(nightly), ignore)]
-#[allow(unused_attributes)]
-#[test]
-fn expandtest() {
-    macrotest::expand("tests/expand/*.rs");
-}
@@ -1,93 +1,79 @@
+#![allow(unused_macro_rules)]
+
+use serde_test::Token;
+use std::iter;
+
 macro_rules! btreeset {
    () => {
        BTreeSet::new()
    };
-    ($($value:expr),+) => {
-        {
-            let mut set = BTreeSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    }
+    ($($value:expr),+) => {{
+        let mut set = BTreeSet::new();
+        $(set.insert($value);)+
+        set
+    }};
 }

 macro_rules! btreemap {
    () => {
        BTreeMap::new()
    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
+    ($($key:expr => $value:expr),+) => {{
+        let mut map = BTreeMap::new();
+        $(map.insert($key, $value);)+
+        map
+    }};
 }

 macro_rules! hashset {
    () => {
        HashSet::new()
    };
-    ($($value:expr),+) => {
-        {
-            let mut set = HashSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    };
-    ($hasher:ident @ $($value:expr),+) => {
-        {
-            use std::hash::BuildHasherDefault;
-            let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
-            $(set.insert($value);)+
-            set
-        }
-    }
+    ($($value:expr),+) => {{
+        let mut set = HashSet::new();
+        $(set.insert($value);)+
+        set
+    }};
+    ($hasher:ident @ $($value:expr),+) => {{
+        use std::hash::BuildHasherDefault;
+        let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
+        $(set.insert($value);)+
+        set
+    }};
 }

 macro_rules! hashmap {
    () => {
        HashMap::new()
    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = HashMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    };
-    ($hasher:ident @ $($key:expr => $value:expr),+) => {
-        {
-            use std::hash::BuildHasherDefault;
-            let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
-            $(map.insert($key, $value);)+
-            map
-        }
+    ($($key:expr => $value:expr),+) => {{
+        let mut map = HashMap::new();
+        $(map.insert($key, $value);)+
+        map
+    }};
+    ($hasher:ident @ $($key:expr => $value:expr),+) => {{
+        use std::hash::BuildHasherDefault;
+        let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
+        $(map.insert($key, $value);)+
+        map
+    }};
+}
+
+pub trait SingleTokenIntoIterator {
+    fn into_iter(self) -> iter::Once<Token>;
+}
+
+impl SingleTokenIntoIterator for Token {
+    fn into_iter(self) -> iter::Once<Token> {
+        iter::once(self)
    }
 }

-macro_rules! seq_impl {
-    (seq $first:expr,) => {
-        seq_impl!(seq $first)
-    };
-    ($first:expr,) => {
-        seq_impl!($first)
-    };
-    (seq $first:expr) => {
-        $first.into_iter()
-    };
-    ($first:expr) => {
-        Some($first).into_iter()
-    };
-    (seq $first:expr , $( $elem: tt)*) => {
-        $first.into_iter().chain(seq!( $($elem)* ))
-    };
-    ($first:expr , $($elem: tt)*) => {
-        Some($first).into_iter().chain(seq!( $($elem)* ))
-    }
-}
 macro_rules! seq {
-    ($($tt: tt)*) => {
-        seq_impl!($($tt)*).collect::<Vec<_>>()
-    };
+    ($($elem:expr),* $(,)?) => {{
+        use crate::macros::SingleTokenIntoIterator;
+        let mut vec = Vec::new();
+        $(<Vec<Token> as Extend<Token>>::extend(&mut vec, $elem.into_iter());)*
+        vec
+    }};
 }
@@ -0,0 +1,3 @@
+mod regression {
+    automod::dir!("tests/regression");
+}
@@ -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,
+    },
+}
@@ -1,4 +1,14 @@
-#![allow(clippy::cast_lossless, clippy::trivially_copy_pass_by_ref)]
+#![allow(
+    clippy::cast_lossless,
+    clippy::derive_partial_eq_without_eq,
+    clippy::from_over_into,
+    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
+    clippy::nonstandard_macro_braces,
+    clippy::too_many_lines,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds,
+    clippy::uninlined_format_args,
+)]

 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -632,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`",
    );
 }

@@ -770,7 +780,7 @@ fn test_rename_enum() {
            Token::StructVariant {
                name: "AliasEnum",
                variant: "sailor_moon",
-                len: 3,
+                len: 5,
            },
            Token::Str("a"),
            Token::I8(0),
@@ -788,7 +798,7 @@ fn test_rename_enum() {
            Token::StructVariant {
                name: "AliasEnum",
                variant: "usagi_tsukino",
-                len: 3,
+                len: 5,
            },
            Token::Str("a"),
            Token::I8(0),
@@ -817,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),
@@ -826,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`",
    );
 }

@@ -1226,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>
@@ -1235,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))
 }
@@ -2293,6 +2298,25 @@ fn test_internally_tagged_enum_containing_flatten() {
    );
 }

+#[test]
+fn test_internally_tagged_enum_new_type_with_unit() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A(()),
+    }
+
+    assert_tokens(
+        &Data::A(()),
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_adjacently_tagged_enum_containing_flatten() {
    #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2633,3 +2657,233 @@ 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)]
+    #[serde(expecting = "something strange...")]
+    struct Unit;
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Newtype(bool);
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Tuple(u32, bool);
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Struct {
+        question: String,
+        answer: u32,
+    }
+
+    assert_de_tokens_error::<Unit>(
+        &[Token::Str("Unit")],
+        r#"invalid type: string "Unit", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Newtype>(
+        &[Token::Str("Newtype")],
+        r#"invalid type: string "Newtype", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Tuple>(
+        &[Token::Str("Tuple")],
+        r#"invalid type: string "Tuple", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Struct>(
+        &[Token::Str("Struct")],
+        r#"invalid type: string "Struct", expected something strange..."#,
+    );
+}
+
+#[test]
+fn test_expecting_message_externally_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        ExternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("ExternallyTagged")],
+        r#"invalid type: string "ExternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Enum { name: "Enum" }, Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_internally_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        InternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("InternallyTagged")],
+        r#"invalid type: string "InternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_adjacently_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag", content = "content")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        AdjacentlyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("AdjacentlyTagged")],
+        r#"invalid type: string "AdjacentlyTagged", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Unit],
+        r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_untagged_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        Untagged,
+    }
+
+    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], r#"something strange..."#);
+}
+
+#[test]
+fn test_expecting_message_identifier_enum() {
+    #[derive(Deserialize)]
+    #[serde(field_identifier)]
+    #[serde(expecting = "something strange...")]
+    enum FieldEnum {
+        Field,
+    }
+
+    #[derive(Deserialize)]
+    #[serde(variant_identifier)]
+    #[serde(expecting = "something strange...")]
+    enum VariantEnum {
+        Variant,
+    }
+
+    assert_de_tokens_error::<FieldEnum>(
+        &[Token::Unit],
+        r#"invalid type: unit value, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<FieldEnum>(
+        &[
+            Token::Enum { name: "FieldEnum" },
+            Token::Str("Unknown"),
+            Token::None,
+        ],
+        r#"invalid type: map, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<VariantEnum>(
+        &[Token::Unit],
+        r#"invalid type: unit value, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<VariantEnum>(
+        &[
+            Token::Enum {
+                name: "VariantEnum",
+            },
+            Token::Str("Unknown"),
+            Token::None,
+        ],
+        r#"invalid type: map, expected something strange..."#,
+    );
+}
@@ -1,3 +1,9 @@
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::items_after_statements,
+    clippy::used_underscore_binding
+)]
+
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};

@@ -90,6 +96,30 @@ fn test_struct() {
    );
 }

+#[test]
+fn test_field_identifier() {
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldStr<'a> {
+        #[serde(borrow)]
+        Str(&'a str),
+    }
+
+    assert_de_tokens(&FieldStr::Str("value"), &[Token::BorrowedStr("value")]);
+
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldBytes<'a> {
+        #[serde(borrow)]
+        Bytes(&'a [u8]),
+    }
+
+    assert_de_tokens(
+        &FieldBytes::Bytes(b"value"),
+        &[Token::BorrowedBytes(b"value")],
+    );
+}
+
 #[test]
 fn test_cow() {
    #[derive(Deserialize)]
@@ -3,11 +3,21 @@
 // types involved.

 #![deny(warnings)]
-#![cfg_attr(feature = "unstable", feature(non_ascii_idents))]
 #![allow(
    unknown_lints,
    mixed_script_confusables,
-    clippy::trivially_copy_pass_by_ref
+    clippy::derive_partial_eq_without_eq,
+    clippy::extra_unused_type_parameters,
+    clippy::items_after_statements,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::must_use_candidate,
+    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
+    clippy::nonstandard_macro_braces,
+    clippy::ptr_arg,
+    clippy::too_many_lines,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
 )]

 use serde::de::DeserializeOwned;
@@ -247,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>();
@@ -266,7 +286,6 @@ fn test_gen() {
    }
    assert::<EmptyEnumVariant>();

-    #[cfg(feature = "unstable")]
    #[derive(Serialize, Deserialize)]
    struct NonAsciiIdents {
        σ: f64,
@@ -642,7 +661,7 @@ fn test_gen() {
    assert::<SkippedVariant<X>>();

    #[derive(Deserialize)]
-    struct ImpliciltyBorrowedOption<'a> {
+    struct ImplicitlyBorrowedOption<'a> {
        option: std::option::Option<&'a str>,
    }

@@ -723,6 +742,24 @@ fn test_gen() {
    }

    deriving!(&'a str);
+
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    #[derive(Deserialize)]
+    struct BorrowLifetimeInsideMacro<'a> {
+        #[serde(borrow = "'a")]
+        f: mac!(Cow<'a, str>),
+    }
+
+    #[derive(Serialize)]
+    struct Struct {
+        #[serde(serialize_with = "vec_first_element")]
+        vec: Vec<Self>,
+    }
 }

 //////////////////////////////////////////////////////////////////////////
@@ -796,3 +833,72 @@ where
 pub fn is_zero(n: &u8) -> bool {
    *n == 0
 }
+
+fn vec_first_element<T, S>(vec: &Vec<T>, serializer: S) -> StdResult<S::Ok, S::Error>
+where
+    T: Serialize,
+    S: Serializer,
+{
+    vec.first().serialize(serializer)
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug, PartialEq, Deserialize)]
+#[serde(tag = "tag")]
+enum InternallyTagged {
+    #[serde(deserialize_with = "deserialize_generic")]
+    Unit,
+
+    #[serde(deserialize_with = "deserialize_generic")]
+    Newtype(i32),
+
+    #[serde(deserialize_with = "deserialize_generic")]
+    Struct { f1: String, f2: u8 },
+}
+
+fn deserialize_generic<'de, T, D>(deserializer: D) -> StdResult<T, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    T::deserialize(deserializer)
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#[repr(packed)]
+pub struct RemotePacked {
+    pub a: u16,
+    pub b: u32,
+}
+
+#[derive(Serialize)]
+#[repr(packed)]
+#[serde(remote = "RemotePacked")]
+pub struct RemotePackedDef {
+    a: u16,
+    b: u32,
+}
+
+impl Drop for RemotePackedDef {
+    fn drop(&mut self) {}
+}
+
+#[repr(packed)]
+pub struct RemotePackedNonCopy {
+    pub a: u16,
+    pub b: String,
+}
+
+#[derive(Deserialize)]
+#[repr(packed)]
+#[serde(remote = "RemotePackedNonCopy")]
+pub struct RemotePackedNonCopyDef {
+    a: u16,
+    b: String,
+}
+
+impl Drop for RemotePackedNonCopyDef {
+    fn drop(&mut self) {}
+}
@@ -1,3 +1,7 @@
+//! Tests for `#[serde(field_identifier)]` and `#[serde(variant_identifier)]`
+
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 use serde::Deserialize;
 use serde_test::{assert_de_tokens, Token};

@@ -27,6 +31,10 @@ fn test_field_identifier() {
        Bbb,
    }

+    assert_de_tokens(&F::Aaa, &[Token::U8(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U16(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U32(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U64(0)]);
    assert_de_tokens(&F::Aaa, &[Token::Str("aaa")]);
    assert_de_tokens(&F::Aaa, &[Token::Bytes(b"aaa")]);
 }
@@ -42,6 +50,10 @@ fn test_unit_fallthrough() {
        Other,
    }

+    assert_de_tokens(&F::Other, &[Token::U8(42)]);
+    assert_de_tokens(&F::Other, &[Token::U16(42)]);
+    assert_de_tokens(&F::Other, &[Token::U32(42)]);
+    assert_de_tokens(&F::Other, &[Token::U64(42)]);
    assert_de_tokens(&F::Other, &[Token::Str("x")]);
 }

@@ -68,5 +80,9 @@ fn test_newtype_fallthrough_generic() {
        Other(T),
    }

+    assert_de_tokens(&F::Other(42u8), &[Token::U8(42)]);
+    assert_de_tokens(&F::Other(42u16), &[Token::U16(42)]);
+    assert_de_tokens(&F::Other(42u32), &[Token::U32(42)]);
+    assert_de_tokens(&F::Other(42u64), &[Token::U64(42)]);
    assert_de_tokens(&F::Other("x".to_owned()), &[Token::Str("x")]);
 }
@@ -1,3 +1,5 @@
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 use serde::de::value::{Error, MapDeserializer, SeqDeserializer};
 use serde::de::{
    DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
@@ -1,5 +1,10 @@
 #![deny(trivial_numeric_casts)]
-#![allow(clippy::redundant_field_names)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::enum_variant_names,
+    clippy::redundant_field_names,
+    clippy::too_many_lines
+)]

 mod bytes;

@@ -994,6 +999,28 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
            Token::StructEnd,
        ],
    );
+
+    assert_de_tokens(
+        &Message::Log { level: Level::Info },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("action"),
+            Token::Str("Log"),
+            Token::Str("level"),
+            Token::BorrowedStr("Info"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Message::Log { level: Level::Info },
+        &[
+            Token::Seq { len: Some(2) },
+            Token::Str("Log"),
+            Token::BorrowedStr("Info"),
+            Token::SeqEnd,
+        ],
+    );
 }

 #[test]
@@ -1877,9 +1904,30 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
            Token::MapEnd,
        ],
    );
+
+    assert_de_tokens(
+        &Message::Info(Info),
+        &[
+            Token::Struct {
+                name: "Message",
+                len: 1,
+            },
+            Token::Str("topic"),
+            Token::Str("Info"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Message::Info(Info),
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Str("Info"),
+            Token::SeqEnd,
+        ],
+    );
 }

-#[deny(safe_packed_borrows)]
 #[test]
 fn test_packed_struct_can_derive_serialize() {
    #[derive(Copy, Clone, Serialize)]
@@ -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 }
+    }
+}
@@ -11,10 +11,12 @@ fn ip_addr_roundtrip() {
    assert_tokens(
        &net::IpAddr::from(*b"1234").compact(),
        &seq![
-            Token::NewtypeVariant { name: "IpAddr", variant: "V4" },
-
+            Token::NewtypeVariant {
+                name: "IpAddr",
+                variant: "V4"
+            },
            Token::Tuple { len: 4 },
-            seq b"1234".iter().map(|&b| Token::U8(b)),
+            b"1234".iter().copied().map(Token::U8),
            Token::TupleEnd,
        ],
    );
@@ -25,14 +27,14 @@ fn socket_addr_roundtrip() {
    assert_tokens(
        &net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
        &seq![
-            Token::NewtypeVariant { name: "SocketAddr", variant: "V6" },
-
+            Token::NewtypeVariant {
+                name: "SocketAddr",
+                variant: "V6"
+            },
            Token::Tuple { len: 2 },
-
            Token::Tuple { len: 16 },
-            seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
+            b"1234567890123456".iter().copied().map(Token::U8),
            Token::TupleEnd,
-
            Token::U16(1234),
            Token::TupleEnd,
        ],
@@ -0,0 +1,88 @@
+#![allow(clippy::used_underscore_binding)]
+
+use serde::{Deserialize, Serialize};
+
+#[test]
+fn test_self() {
+    pub trait Trait {
+        type Assoc;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    pub struct Generics<T: Trait<Assoc = Self>>
+    where
+        Self: Trait<Assoc = Self>,
+        <Self as Trait>::Assoc: Sized,
+    {
+        _f: T,
+    }
+
+    impl<T: Trait<Assoc = Self>> Trait for Generics<T> {
+        type Assoc = Self;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    pub struct Struct {
+        _f1: Box<Self>,
+        _f2: Box<<Self as Trait>::Assoc>,
+        _f4: [(); Self::ASSOC],
+        _f5: [(); Self::assoc()],
+    }
+
+    impl Struct {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Struct {
+        type Assoc = Self;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    struct Tuple(
+        Box<Self>,
+        Box<<Self as Trait>::Assoc>,
+        [(); Self::ASSOC],
+        [(); Self::assoc()],
+    );
+
+    impl Tuple {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Tuple {
+        type Assoc = Self;
+    }
+
+    #[derive(Deserialize, Serialize)]
+    enum Enum {
+        Struct {
+            _f1: Box<Self>,
+            _f2: Box<<Self as Trait>::Assoc>,
+            _f4: [(); Self::ASSOC],
+            _f5: [(); Self::assoc()],
+        },
+        Tuple(
+            Box<Self>,
+            Box<<Self as Trait>::Assoc>,
+            [(); Self::ASSOC],
+            [(); Self::assoc()],
+        ),
+    }
+
+    impl Enum {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Enum {
+        type Assoc = Self;
+    }
+}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`test_suite/tests/expand/*.expanded.rs linguist-generated`