Release 1.0.140

Invert build.rs cfgs in serde_derive

.gitattributes

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

.github/ISSUE_TEMPLATE/4-discussion.md

@@ -1,7 +0,0 @@
----
-name: Help or discussion
-about: This is the right place
-
----
-
-

.github/workflows/ci.yml

@@ -0,0 +1,194 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  schedule: [cron: "40 1 * * *"]
+
+env:
+  RUSTFLAGS: -Dwarnings
+
+jobs:
+  test:
+    name: Test suite
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cd test_suite && cargo test --features unstable
+      - uses: dtolnay/install@cargo-expand
+        if: github.event_name != 'pull_request'
+      - run: cd test_suite && cargo test --features expandtest --test expandtest -- --include-ignored
+        if: github.event_name != 'pull_request'
+
+  windows:
+    name: Test suite (windows)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
+
+  stable:
+    name: Rust ${{matrix.rust}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [stable, beta]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+      - run: cd serde && cargo build --features rc
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde_test && cargo build
+      - run: cd serde_test && cargo test --features serde/derive,serde/rc
+
+  nightly:
+    name: Rust nightly ${{matrix.os == 'windows' && '(windows)' || ''}}
+    runs-on: ${{matrix.os}}-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu, windows]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cd serde && cargo build
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde && cargo build --no-default-features --features alloc
+      - run: cd serde && cargo build --no-default-features --features rc,alloc
+      - run: cd serde && cargo test --features derive,rc,unstable
+      - run: cd test_suite/no_std && cargo build
+        if: matrix.os != 'windows'
+      - run: cd serde_derive && cargo check --tests
+        env:
+          RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
+        if: matrix.os != 'windows'
+
+  msrv:
+    name: Rust 1.13.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@1.13.0
+      - name: Get timestamp for cache
+        id: date
+        run: echo ::set-output name=yearmo::$(date +%Y%m)
+      - uses: actions/cache@v1
+        with:
+          path: ~/.cargo/registry/index
+          key: cargo-registry-index-${{steps.date.outputs.yearmo}}
+      - run: cd serde && cargo build --features rc
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde_test && cargo build
+
+  build:
+    name: Rust ${{matrix.rust}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [1.19.0, 1.20.0, 1.21.0, 1.25.0, 1.26.0, 1.34.0]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde && cargo build
+
+  more:
+    name: Rust ${{matrix.rust}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [1.27.0, 1.28.0]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+        # Work around failing to parse manifest because editions are unstable.
+      - run: sed -i /test_suite/d Cargo.toml
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde && cargo build
+
+  derive:
+    name: Rust 1.31.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@1.31.0
+      - run: cd serde && cargo check --no-default-features
+      - run: cd serde && cargo check
+      - run: cd serde_derive && cargo check
+
+  alloc:
+    name: Rust 1.36.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@1.36.0
+      - run: cd serde && cargo build --no-default-features --features alloc
+
+  emscripten:
+    name: Emscripten
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 9
+      - name: Install cargo-web
+        run: |
+          CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
+          CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
+          CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
+          mkdir -p ~/.cargo/bin
+          curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
+          chmod +x ~/.cargo/bin/cargo-web
+      - run: cd test_suite && cargo web test --target=asmjs-unknown-emscripten --nodejs
+        continue-on-error: true
+      - run: cd test_suite && cargo web test --target=wasm32-unknown-emscripten --nodejs
+        continue-on-error: true
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@clippy
+      - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
+      - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+      - 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
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@miri
+      - run: cd serde && cargo miri test --features derive,rc,unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+      - run: cd test_suite && cargo miri test --features unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+
+  outdated:
+    name: Outdated
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1

.travis.yml

@@ -1,107 +0,0 @@
-language: rust
-
-matrix:
-  include:
-    - rust: stable
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --features rc
-        - cargo build --no-default-features
-        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo build
-        - cargo test --features serde/derive,serde/rc
-
-    - rust: beta
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --features rc
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test
-
-    - rust: nightly
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build
-        - cargo build --no-default-features
-        - cargo build --no-default-features --features alloc
-        - cargo build --no-default-features --features rc,alloc
-        - cargo test --features derive,rc,unstable
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test --features unstable
-        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
-        - cargo build
-
-    - rust: 1.13.0
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --features rc
-        - cargo build --no-default-features
-        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo build
-
-    - rust: 1.19.0
-    - rust: 1.20.0
-    - rust: 1.21.0
-    - rust: 1.25.0
-    - rust: 1.26.0
-
-    # Work around failing to parse manifest because editions are unstable.
-    - rust: 1.27.0
-      before_script: sed -i /test_suite/d Cargo.toml
-    - rust: 1.28.0
-      before_script: sed -i /test_suite/d Cargo.toml
-
-    - rust: 1.31.0
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
-        - cargo build
-
-    - rust: 1.34.0
-
-    - rust: 1.36.0
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --no-default-features --features alloc
-
-    - rust: nightly
-      name: Clippy
-      script:
-        - rustup component add clippy || travis_terminate 0
-        - cargo clippy -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo clippy --features rc,unstable -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
-        - cargo clippy -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo clippy -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo clippy --tests --features unstable -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
-        - cargo clippy -- -D clippy::all
-
-    - rust: nightly
-      name: Emscripten
-      script:
-        - 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"
-
-        - nvm install 9
-        - mkdir -p ~/.cargo/bin
-        - curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
-        - chmod +x ~/.cargo/bin/cargo-web
-
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo web test --target=asmjs-unknown-emscripten --nodejs
-        - cargo web test --target=wasm32-unknown-emscripten --nodejs
-
-  allow_failures:
-    - rust: nightly
-      name: Clippy
-    - rust: nightly
-      name: Emscripten
-
-script:
-  - cd "${TRAVIS_BUILD_DIR}/serde"
-  - cargo build --no-default-features
-  - cargo build

CONTRIBUTING.md

@@ -4,11 +4,6 @@ Serde welcomes contribution from everyone in the form of suggestions, bug
 reports, pull requests, and feedback. This document gives some guidance if you
 are thinking of helping us.
 
-Please reach out here in a GitHub issue or in the #serde IRC channel on
-[`irc.mozilla.org`] if we can do anything to help you contribute.
-
-[`irc.mozilla.org`]: https://wiki.mozilla.org/IRC
-
 ## Submitting bug reports and feature requests
 
 Serde development is spread across lots of repositories, but this serde-rs/serde
@@ -36,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
@@ -63,4 +52,4 @@ In all Serde-related forums, we follow the [Rust Code of Conduct]. For
 escalation or moderation issues please contact Erick (erick.tryzelaar@gmail.com)
 instead of the Rust moderation team.
 
-[Rust Code of Conduct]: https://www.rust-lang.org/conduct.html
+[Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct

README.md

@@ -1,11 +1,13 @@
-# Serde   [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.13+]][rustc]
+# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
 
-[Build Status]: https://api.travis-ci.org/serde-rs/serde.svg?branch=master
-[travis]: https://travis-ci.org/serde-rs/serde
+[Build Status]: https://img.shields.io/github/workflow/status/serde-rs/serde/CI/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
-[Rustc Version 1.13+]: https://img.shields.io/badge/rustc-1.13+-lightgray.svg
-[rustc]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
+[serde: rustc 1.13+]: https://img.shields.io/badge/serde-rustc_1.13+-lightgray.svg
+[serde_derive: rustc 1.31+]: https://img.shields.io/badge/serde_derive-rustc_1.31+-lightgray.svg
+[Rust 1.13]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
+[Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
 
 **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
 
@@ -73,13 +75,26 @@ fn main() {
 
 ## Getting help
 
-Serde developers live in the #serde channel on [`irc.mozilla.org`][irc]. The
-\#rust channel is also a good resource with generally faster response time but
-less specific knowledge about Serde. If IRC is not your thing or you don't get a
-good response, we are happy to respond to [GitHub issues][issues] as well.
+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
+[#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.
 
-[irc]: https://wiki.mozilla.org/IRC
-[issues]: https://github.com/serde-rs/serde/issues/new/choose
+[#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
+[discourse]: https://users.rust-lang.org
 
 <br>
 

appveyor.yml

@@ -1,39 +0,0 @@
-environment:
-  matrix:
-    - APPVEYOR_RUST_CHANNEL: stable
-    - APPVEYOR_RUST_CHANNEL: nightly
-
-install:
-  # Install rust, x86_64-pc-windows-msvc host
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
-  - rustup-init.exe -y --default-host x86_64-pc-windows-msvc --default-toolchain %APPVEYOR_RUST_CHANNEL%
-  - set PATH=C:\msys64\usr\bin;%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -vV
-  - cargo -vV
-
-build: false
-
-for:
-  - matrix:
-      only:
-        - APPVEYOR_RUST_CHANNEL: stable
-    test_script:
-      - cd %APPVEYOR_BUILD_FOLDER%\serde
-      - cargo build --features rc
-      - cargo build --no-default-features
-      - cd %APPVEYOR_BUILD_FOLDER%\serde_test
-      - cargo build
-      - cargo test --features serde/derive,serde/rc
-
-  - matrix:
-      only:
-        - APPVEYOR_RUST_CHANNEL: nightly
-    test_script:
-      - cd %APPVEYOR_BUILD_FOLDER%\serde
-      - cargo build
-      - cargo build --no-default-features
-      - cargo build --no-default-features --features alloc
-      - cargo build --no-default-features --features rc,alloc
-      - cargo test --features derive,rc,unstable
-      - cd %APPVEYOR_BUILD_FOLDER%\test_suite
-      - cargo test --features unstable

crates-io.md

@@ -43,10 +43,23 @@ fn main() {
 
 ## Getting help
 
-Serde developers live in the #serde channel on [`irc.mozilla.org`][irc]. The
-\#rust channel is also a good resource with generally faster response time but
-less specific knowledge about Serde. If IRC is not your thing or you don't get a
-good response, we are happy to respond to [GitHub issues][issues] as well.
+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
+[#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.
 
-[irc]: https://wiki.mozilla.org/IRC
-[issues]: https://github.com/serde-rs/serde/issues/new/choose
+[#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
+[discourse]: https://users.rust-lang.org

rustfmt.toml

@@ -1 +0,0 @@
-error_on_line_overflow = false

serde/.clippy.toml

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

serde/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "serde"
-version = "1.0.99" # remember to update html_root_url
+version = "1.0.140" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+rust-version = "1.13"
 license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
 homepage = "https://serde.rs"
@@ -10,15 +11,11 @@ documentation = "https://docs.serde.rs/serde/"
 keywords = ["serde", "serialization", "no_std"]
 categories = ["encoding"]
 readme = "crates-io.md"
-include = ["Cargo.toml", "build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 build = "build.rs"
 
-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
-
 [dependencies]
-serde_derive = { version = "1.0", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.140", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }
@@ -26,6 +23,9 @@ serde_derive = { version = "1.0", path = "../serde_derive" }
 [package.metadata.playground]
 features = ["derive", "rc"]
 
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
 
 ### FEATURES #################################################################
 

serde/build.rs

@@ -17,81 +17,96 @@ fn main() {
     // std::collections::Bound was stabilized in Rust 1.17
     // but it was moved to core::ops later in Rust 1.26:
     // https://doc.rust-lang.org/core/ops/enum.Bound.html
-    if minor >= 26 {
-        println!("cargo:rustc-cfg=ops_bound");
-    } else if minor >= 17 && cfg!(feature = "std") {
-        println!("cargo:rustc-cfg=collections_bound");
+    if minor < 26 {
+        println!("cargo:rustc-cfg=no_ops_bound");
+        if minor < 17 {
+            println!("cargo:rustc-cfg=no_collections_bound");
+        }
     }
 
     // core::cmp::Reverse stabilized in Rust 1.19:
     // https://doc.rust-lang.org/stable/core/cmp/struct.Reverse.html
-    if minor >= 19 {
-        println!("cargo:rustc-cfg=core_reverse");
+    if minor < 19 {
+        println!("cargo:rustc-cfg=no_core_reverse");
     }
 
-    // CString::into_boxed_c_str stabilized in Rust 1.20:
+    // 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
-    if minor >= 20 {
-        println!("cargo:rustc-cfg=de_boxed_c_str");
+    // https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.into_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://github.com/rust-lang/rust/pull/50808
-    if minor >= 28 {
-        println!("cargo:rustc-cfg=num_nonzero");
+    // https://blog.rust-lang.org/2018/08/02/Rust-1.28.html#library-stabilizations
+    if minor < 28 {
+        println!("cargo:rustc-cfg=no_num_nonzero");
     }
 
-    // TryFrom, Atomic types, and non-zero signed integers stabilized in Rust 1.34:
+    // Current minimum supported version of serde_derive crate is Rust 1.31.
+    if minor < 31 {
+        println!("cargo:rustc-cfg=no_serde_derive");
+    }
+
+    // TryFrom, Atomic types, non-zero signed integers, and SystemTime::checked_add
+    // stabilized in Rust 1.34:
     // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
     // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#library-stabilizations
-    if minor >= 34 {
-        println!("cargo:rustc-cfg=core_try_from");
-        println!("cargo:rustc-cfg=num_nonzero_signed");
+    if minor < 34 {
+        println!("cargo:rustc-cfg=no_core_try_from");
+        println!("cargo:rustc-cfg=no_num_nonzero_signed");
+        println!("cargo:rustc-cfg=no_systemtime_checked_add");
+    }
 
-        // Whitelist of archs that support std::sync::atomic module. Ideally we
-        // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
-        // Instead this is based on rustc's src/librustc_target/spec/*.rs.
-        let has_atomic64 = target.starts_with("x86_64")
-            || target.starts_with("i686")
-            || target.starts_with("aarch64")
-            || target.starts_with("powerpc64")
-            || target.starts_with("sparc64")
-            || target.starts_with("mips64el");
-        let has_atomic32 = has_atomic64 || emscripten;
-        if has_atomic64 {
-            println!("cargo:rustc-cfg=std_atomic64");
-        }
-        if has_atomic32 {
-            println!("cargo:rustc-cfg=std_atomic");
-        }
+    // Whitelist of archs that support std::sync::atomic module. Ideally we
+    // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
+    // Instead this is based on rustc's compiler/rustc_target/src/spec/*.rs.
+    let has_atomic64 = target.starts_with("x86_64")
+        || target.starts_with("i686")
+        || target.starts_with("aarch64")
+        || target.starts_with("powerpc64")
+        || target.starts_with("sparc64")
+        || target.starts_with("mips64el")
+        || target.starts_with("riscv64");
+    let has_atomic32 = has_atomic64 || emscripten;
+    if minor < 34 || !has_atomic64 {
+        println!("cargo:rustc-cfg=no_std_atomic64");
+    }
+    if minor < 34 || !has_atomic32 {
+        println!("cargo:rustc-cfg=no_std_atomic");
     }
 }
 

serde/src/de/format.rs

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

serde/src/de/from_primitive.rs

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

serde/src/de/ignored_any.rs

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

serde/src/de/mod.rs

@@ -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/TyOverby/bincode
+//! [`bincode`]: https://github.com/bincode-org/bincode
 //! [`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,13 +118,21 @@ use lib::*;
 
 pub mod value;
 
-mod from_primitive;
+#[cfg(not(no_integer128))]
+mod format;
 mod ignored_any;
 mod impls;
 mod utf8;
 
 pub use self::ignored_any::IgnoredAny;
 
+#[cfg(feature = "std")]
+#[doc(no_inline)]
+pub use std::error::Error as StdError;
+#[cfg(not(feature = "std"))]
+#[doc(no_inline)]
+pub use std_error::Error as StdError;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! declare_error_trait {
@@ -288,7 +296,7 @@ macro_rules! declare_error_trait {
 }
 
 #[cfg(feature = "std")]
-declare_error_trait!(Error: Sized + error::Error);
+declare_error_trait!(Error: Sized + StdError);
 
 #[cfg(not(feature = "std"))]
 declare_error_trait!(Error: Sized + Debug + Display);
@@ -386,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),
@@ -700,6 +708,11 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 ///             where
 ///                 A: SeqAccess<'de>,
 ///             {
+///                 // Decrease the number of reallocations if there are many elements
+///                 if let Some(size_hint) = seq.size_hint() {
+///                    self.0.reserve(size_hint);
+///                 }
+///
 ///                 // Visit each element in the inner array and push it onto
 ///                 // the existing vector.
 ///                 while let Some(elem) = seq.next_element()? {
@@ -787,7 +800,7 @@ where
 ///
 /// The role of this trait is to define the deserialization half of the [Serde
 /// data model], which is a way to categorize every Rust data type into one of
-/// 29 possible types. Each method of the `Serializer` trait corresponds to one
+/// 29 possible types. Each method of the `Deserializer` trait corresponds to one
 /// of the types of the data model.
 ///
 /// Implementations of `Deserialize` map themselves into this data model by
@@ -1001,7 +1014,7 @@ pub trait Deserializer<'de>: Sized {
     /// `Deserializer`.
     ///
     /// If the `Visitor` would benefit from taking ownership of `String` data,
-    /// indiciate this to the `Deserializer` by using `deserialize_string`
+    /// indicate this to the `Deserializer` by using `deserialize_string`
     /// instead.
     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
@@ -1207,6 +1220,20 @@ pub trait Deserializer<'de>: Sized {
     fn is_human_readable(&self) -> bool {
         true
     }
+
+    // Not public API.
+    #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
+    #[doc(hidden)]
+    fn __deserialize_content<V>(
+        self,
+        _: ::actually_private::T,
+        visitor: V,
+    ) -> Result<::private::de::Content<'de>, Self::Error>
+    where
+        V: Visitor<'de, Value = ::private::de::Content<'de>>,
+    {
+        self.deserialize_any(visitor)
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1346,8 +1373,10 @@ pub trait Visitor<'de>: Sized {
         where
             E: Error,
         {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("i128"), &self))
+            let mut buf = [0u8; 58];
+            let mut writer = format::Buf::new(&mut buf);
+            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
+            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
         }
     }
 
@@ -1406,8 +1435,10 @@ pub trait Visitor<'de>: Sized {
         where
             E: Error,
         {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("u128"), &self))
+            let mut buf = [0u8; 57];
+            let mut writer = format::Buf::new(&mut buf);
+            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
+            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
         }
     }
 
@@ -1708,7 +1739,7 @@ pub trait SeqAccess<'de> {
     }
 }
 
-impl<'de, 'a, A> SeqAccess<'de> for &'a mut A
+impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
 where
     A: SeqAccess<'de>,
 {
@@ -1861,7 +1892,7 @@ pub trait MapAccess<'de> {
     }
 }
 
-impl<'de, 'a, A> MapAccess<'de> for &'a mut A
+impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A
 where
     A: MapAccess<'de>,
 {

serde/src/de/seed.rs

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

serde/src/de/value.rs

@@ -24,8 +24,8 @@
 use lib::*;
 
 use self::private::{First, Second};
-use 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"))]
@@ -1034,7 +1221,7 @@ where
         let value = self.value.take();
         // Panic because this indicates a bug in the program rather than an
         // expected failure.
-        let value = value.expect("MapAccess::visit_value called before visit_key");
+        let value = value.expect("MapAccess::next_value called before next_key");
         seed.deserialize(value.into_deserializer())
     }
 
@@ -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()
     }
 }
@@ -1331,7 +1515,6 @@ mod private {
 
     use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};
 
-    #[derive(Clone, Debug)]
     pub struct UnitOnly<E> {
         marker: PhantomData<E>,
     }
@@ -1390,7 +1573,6 @@ mod private {
         }
     }
 
-    #[derive(Clone, Debug)]
     pub struct MapAsEnum<A> {
         map: A,
     }

serde/src/export.rs

@@ -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}")
-    }
-}

serde/src/integer128.rs

@@ -10,7 +10,7 @@
 /// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
-/// # use serde::private::ser::Error;
+/// # use serde::__private::doc::Error;
 /// #
 /// # struct MySerializer;
 /// #
@@ -66,7 +66,7 @@
 ///     ($($tt:tt)*) => {};
 /// }
 /// ```
-#[cfg(integer128)]
+#[cfg(not(no_integer128))]
 #[macro_export]
 macro_rules! serde_if_integer128 {
     ($($tt:tt)*) => {
@@ -74,7 +74,7 @@ macro_rules! serde_if_integer128 {
     };
 }
 
-#[cfg(not(integer128))]
+#[cfg(no_integer128)]
 #[macro_export]
 #[doc(hidden)]
 macro_rules! serde_if_integer128 {

serde/src/lib.rs

@@ -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,
@@ -37,8 +35,8 @@
 //!   used for IPC within the Servo rendering engine.
 //! - [CBOR], a Concise Binary Object Representation designed for small message
 //!   size without the need for version negotiation.
-//! - [YAML], a popular human-friendly configuration language that ain't markup
-//!   language.
+//! - [YAML], a self-proclaimed human-friendly configuration language that ain't
+//!   markup language.
 //! - [MessagePack], an efficient binary format that resembles a compact JSON.
 //! - [TOML], a minimal configuration format used by [Cargo].
 //! - [Pickle], a format common in the Python world.
@@ -46,53 +44,67 @@
 //! - [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.
-//! - [URL], the x-www-form-urlencoded format.
+//! - [JSON5], a superset of JSON including some productions from ES5.
+//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
+//! - [URL] query strings, in the x-www-form-urlencoded format.
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(deserialization only)*
 //! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
 //!   Rust structs. *(deserialization only)*
+//! - [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.
+//! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
+//!   and from DynamoDB.
 //!
 //! [JSON]: https://github.com/serde-rs/json
-//! [Bincode]: https://github.com/TyOverby/bincode
-//! [CBOR]: https://github.com/pyfisch/cbor
+//! [Bincode]: https://github.com/bincode-org/bincode
+//! [CBOR]: https://github.com/enarx/ciborium
 //! [YAML]: https://github.com/dtolnay/serde-yaml
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
 //! [TOML]: https://github.com/alexcrichton/toml-rs
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [RON]: https://github.com/ron-rs/ron
-//! [BSON]: https://github.com/zonyitoo/bson-rs
+//! [BSON]: https://github.com/mongodb/bson-rust
 //! [Avro]: https://github.com/flavray/avro-rs
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
-//! [URL]: https://github.com/nox/serde_urlencoded
+//! [Postcard]: https://github.com/jamesmunns/postcard
+//! [URL]: https://docs.rs/serde_qs
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
-//! [Cargo]: http://doc.crates.io/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
+//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
+//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
+//! [S-expressions]: https://github.com/rotty/lexpr-rs
+//! [D-Bus]: https://docs.rs/zvariant
+//! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
+//! [DynamoDB Items]: https://docs.rs/serde_dynamo
+//! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.99")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.140")]
 // 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(specialization, never_type))]
+#![cfg_attr(feature = "unstable", feature(never_type))]
 #![allow(unknown_lints, bare_trait_objects, deprecated)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy and clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
+        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+        unnested_or_patterns,
+        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
+        semicolon_if_nothing_returned,
         // not available in our oldest supported compiler
-        checked_conversions,
         empty_enum,
-        redundant_field_names,
-        redundant_static_lifetimes,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
         // integer and float ser/de requires these sorts of casts
         cast_possible_truncation,
         cast_possible_wrap,
@@ -100,15 +112,32 @@
         // things are often more readable this way
         cast_lossless,
         module_name_repetitions,
+        option_if_let_else,
         single_match_else,
         type_complexity,
         use_self,
         zero_prefixed_literal,
+        // correctly used
+        derive_partial_eq_without_eq,
+        enum_glob_use,
+        explicit_auto_deref,
+        let_underscore_drop,
+        map_err_ignore,
+        new_without_default,
+        result_unit_err,
+        wildcard_imports,
         // not practical
         needless_pass_by_value,
         similar_names,
+        too_many_lines,
         // preference
         doc_markdown,
+        unseparated_literal_suffix,
+        // false positive
+        needless_doctest_main,
+        // noisy
+        missing_errors_doc,
+        must_use_candidate,
     )
 )]
 // Rustc lints.
@@ -130,7 +159,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};
@@ -141,6 +170,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};
@@ -192,35 +222,33 @@ mod lib {
     #[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", not(no_std_atomic)))]
     pub use std::sync::atomic::{
         AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
         AtomicUsize, Ordering,
     };
-    #[cfg(all(feature = "std", std_atomic64))]
+    #[cfg(all(feature = "std", not(no_std_atomic64)))]
     pub use std::sync::atomic::{AtomicI64, AtomicU64};
 
-    #[cfg(any(core_duration, feature = "std"))]
+    #[cfg(any(feature = "std", not(no_core_duration)))]
     pub use self::core::time::Duration;
 }
 
@@ -240,13 +268,21 @@ 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;
+
+#[path = "de/seed.rs"]
+mod seed;
+
+#[cfg(not(feature = "std"))]
+mod std_error;
 
 // Re-export #[derive(Serialize, Deserialize)].
 //
@@ -260,3 +296,8 @@ extern crate serde_derive;
 #[cfg(feature = "serde_derive")]
 #[doc(hidden)]
 pub use serde_derive::*;
+
+#[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
+mod actually_private {
+    pub struct T;
+}

serde/src/macros.rs

@@ -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>,
         {

serde/src/private/de.rs

@@ -1,9 +1,10 @@
 use lib::*;
 
-use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
+use de::value::{BorrowedBytesDeserializer, BytesDeserializer};
+use de::{Deserialize, Deserializer, Error, IntoDeserializer, Visitor};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use de::{MapAccess, Unexpected};
+use de::{DeserializeSeed, MapAccess, Unexpected};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub use self::content::{
@@ -12,6 +13,8 @@ pub use self::content::{
     TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
 };
 
+pub use seed::InPlaceSeed;
+
 /// If the missing field is of type `Option<T>` then treat is as `None`,
 /// otherwise it is an error.
 pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
@@ -53,9 +56,10 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub fn borrow_cow_str<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, str>, D::Error>
+pub fn borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
 where
     D: Deserializer<'de>,
+    R: From<Cow<'a, str>>,
 {
     struct CowStrVisitor;
 
@@ -121,13 +125,14 @@ where
         }
     }
 
-    deserializer.deserialize_str(CowStrVisitor)
+    deserializer.deserialize_str(CowStrVisitor).map(From::from)
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub fn borrow_cow_bytes<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, [u8]>, D::Error>
+pub fn borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
 where
     D: Deserializer<'de>,
+    R: From<Cow<'a, [u8]>>,
 {
     struct CowBytesVisitor;
 
@@ -181,30 +186,9 @@ where
         }
     }
 
-    deserializer.deserialize_bytes(CowBytesVisitor)
-}
-
-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,
-        }
-    }
+    deserializer
+        .deserialize_bytes(CowBytesVisitor)
+        .map(From::from)
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -221,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,
@@ -231,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),
 
@@ -310,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)
         }
     }
 
@@ -820,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,
             }
         }
@@ -857,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>
@@ -1036,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>
@@ -1175,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>
@@ -1293,8 +1288,9 @@ mod content {
                 //     }
                 //
                 // We want {"topic":"Info"} to deserialize even though
-                // ordinarily unit structs do not deserialize from empty map.
+                // ordinarily unit structs do not deserialize from empty map/seq.
                 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
+                Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(),
                 _ => self.deserialize_any(visitor),
             }
         }
@@ -1432,6 +1428,18 @@ mod content {
             drop(self);
             visitor.visit_unit()
         }
+
+        fn __deserialize_content<V>(
+            self,
+            _: actually_private::T,
+            visitor: V,
+        ) -> Result<Content<'de>, Self::Error>
+        where
+            V: Visitor<'de, Value = Content<'de>>,
+        {
+            let _ = visitor;
+            Ok(self.content)
+        }
     }
 
     impl<'de, E> ContentDeserializer<'de, E> {
@@ -1558,7 +1566,7 @@ mod content {
                     other.unexpected(),
                     &"struct variant",
                 )),
-                _ => Err(de::Error::invalid_type(
+                None => Err(de::Error::invalid_type(
                     de::Unexpected::UnitVariant,
                     &"struct variant",
                 )),
@@ -1747,6 +1755,25 @@ mod content {
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
+
+        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
     }
 
     fn visit_content_seq_ref<'a, 'de, V, E>(
@@ -1894,25 +1921,14 @@ mod content {
         where
             V: Visitor<'de>,
         {
-            match *self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
         }
 
         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where
             V: Visitor<'de>,
         {
-            match *self.content {
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
+            self.deserialize_float(visitor)
         }
 
         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -2135,6 +2151,18 @@ mod content {
         {
             visitor.visit_unit()
         }
+
+        fn __deserialize_content<V>(
+            self,
+            _: actually_private::T,
+            visitor: V,
+        ) -> Result<Content<'de>, Self::Error>
+        where
+            V: Visitor<'de, Value = Content<'de>>,
+        {
+            let _ = visitor;
+            Ok(self.content.clone())
+        }
     }
 
     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
@@ -2248,7 +2276,7 @@ mod content {
                     other.unexpected(),
                     &"struct variant",
                 )),
-                _ => Err(de::Error::invalid_type(
+                None => Err(de::Error::invalid_type(
                     de::Unexpected::UnitVariant,
                     &"struct variant",
                 )),
@@ -2470,7 +2498,7 @@ mod content {
         where
             M: MapAccess<'de>,
         {
-            while let Some(_) = try!(access.next_entry::<IgnoredAny, IgnoredAny>()) {}
+            while try!(access.next_entry::<IgnoredAny, IgnoredAny>()).is_some() {}
             Ok(())
         }
     }
@@ -2510,6 +2538,13 @@ mod content {
         {
             Ok(())
         }
+
+        fn visit_none<E>(self) -> Result<(), E>
+        where
+            E: de::Error,
+        {
+            Ok(())
+        }
     }
 }
 
@@ -2531,11 +2566,13 @@ pub trait IdentifierDeserializer<'de, E: Error> {
     fn from(self) -> Self::Deserializer;
 }
 
-impl<'de, E> IdentifierDeserializer<'de, E> for u32
+pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
+
+impl<'de, E> IdentifierDeserializer<'de, E> for u64
 where
     E: Error,
 {
-    type Deserializer = <u32 as IntoDeserializer<'de, E>>::Deserializer;
+    type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
 
     fn from(self) -> Self::Deserializer {
         self.into_deserializer()
@@ -2547,20 +2584,6 @@ pub struct StrDeserializer<'a, E> {
     marker: PhantomData<E>,
 }
 
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
-where
-    E: Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        StrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
 where
     E: Error,
@@ -2581,26 +2604,12 @@ where
     }
 }
 
-pub struct BytesDeserializer<'a, E> {
-    value: &'a [u8],
+pub struct BorrowedStrDeserializer<'de, E> {
+    value: &'de str,
     marker: PhantomData<E>,
 }
 
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
-where
-    E: Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BytesDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
+impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
 where
     E: Error,
 {
@@ -2610,7 +2619,7 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_bytes(self.value)
+        visitor.visit_borrowed_str(self.value)
     }
 
     forward_to_deserialize_any! {
@@ -2620,21 +2629,53 @@ where
     }
 }
 
-/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
-///
-/// Wraps a mutable reference and calls deserialize_in_place on it.
-pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
-
-impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
 where
-    T: Deserialize<'de>,
+    E: Error,
 {
-    type Value = ();
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize_in_place(deserializer, self.0)
+    type Deserializer = StrDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        StrDeserializer {
+            value: self,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedStrDeserializer<'de, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BorrowedStrDeserializer {
+            value: self.0,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
+where
+    E: Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BytesDeserializer::new(self)
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedBytesDeserializer<'de, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BorrowedBytesDeserializer::new(self.0)
     }
 }
 
@@ -2752,6 +2793,13 @@ where
         }
     }
 
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
     forward_to_deserialize_other! {
         deserialize_bool()
         deserialize_i8()
@@ -2769,7 +2817,6 @@ where
         deserialize_string()
         deserialize_bytes()
         deserialize_byte_buf()
-        deserialize_unit()
         deserialize_unit_struct(&'static str)
         deserialize_seq()
         deserialize_tuple(usize)
@@ -2810,7 +2857,7 @@ where
     where
         T: DeserializeSeed<'de>,
     {
-        while let Some(item) = self.iter.next() {
+        for item in &mut self.iter {
             // Items in the vector are nulled out when used by a struct.
             if let Some((ref key, ref content)) = *item {
                 self.pending_content = Some(content);
@@ -2912,7 +2959,7 @@ where
     where
         T: DeserializeSeed<'de>,
     {
-        while let Some(item) = self.iter.next() {
+        for item in &mut self.iter {
             if let Some((ref key, ref content)) = *item {
                 // Do not take(), instead borrow this entry. The internally tagged
                 // enum does its own buffering so we can't tell whether this entry

serde/src/private/doc.rs

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

serde/src/private/mod.rs

@@ -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}")
+    }
+}

serde/src/private/ser.rs

@@ -335,33 +335,6 @@ where
     }
 }
 
-/// Used only by Serde doc tests. Not public API.
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Error;
-
-impl ser::Error for Error {
-    fn custom<T>(_: T) -> Self
-    where
-        T: Display,
-    {
-        unimplemented!()
-    }
-}
-
-#[cfg(feature = "std")]
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        unimplemented!()
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        unimplemented!()
-    }
-}
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 mod content {
     use lib::*;
@@ -452,7 +425,6 @@ mod content {
         }
     }
 
-    #[derive(Debug)]
     pub enum Content {
         Bool(bool),
 
@@ -1032,7 +1004,7 @@ impl<'a, M> FlatMapSerializer<'a, M>
 where
     M: SerializeMap + 'a,
 {
-    fn bad_type(self, what: Unsupported) -> M::Error {
+    fn bad_type(what: Unsupported) -> M::Error {
         ser::Error::custom(format_args!(
             "can only flatten structs and maps (got {})",
             what
@@ -1057,59 +1029,59 @@ where
     type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a, M>;
 
     fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Boolean))
+        Err(Self::bad_type(Unsupported::Boolean))
     }
 
     fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Float))
+        Err(Self::bad_type(Unsupported::Float))
     }
 
     fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Float))
+        Err(Self::bad_type(Unsupported::Float))
     }
 
     fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Char))
+        Err(Self::bad_type(Unsupported::Char))
     }
 
     fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::String))
+        Err(Self::bad_type(Unsupported::String))
     }
 
     fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::ByteArray))
+        Err(Self::bad_type(Unsupported::ByteArray))
     }
 
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
@@ -1124,11 +1096,11 @@ where
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Unit))
+        Ok(())
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::UnitStruct))
+        Err(Self::bad_type(Unsupported::UnitStruct))
     }
 
     fn serialize_unit_variant(
@@ -1137,7 +1109,7 @@ where
         _: u32,
         _: &'static str,
     ) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Enum))
+        Err(Self::bad_type(Unsupported::Enum))
     }
 
     fn serialize_newtype_struct<T: ?Sized>(
@@ -1166,11 +1138,11 @@ where
     }
 
     fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(self.bad_type(Unsupported::Sequence))
+        Err(Self::bad_type(Unsupported::Sequence))
     }
 
     fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(self.bad_type(Unsupported::Tuple))
+        Err(Self::bad_type(Unsupported::Tuple))
     }
 
     fn serialize_tuple_struct(
@@ -1178,7 +1150,7 @@ where
         _: &'static str,
         _: usize,
     ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(self.bad_type(Unsupported::TupleStruct))
+        Err(Self::bad_type(Unsupported::TupleStruct))
     }
 
     fn serialize_tuple_variant(
@@ -1188,7 +1160,7 @@ where
         _: &'static str,
         _: usize,
     ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(self.bad_type(Unsupported::Enum))
+        Err(Self::bad_type(Unsupported::Enum))
     }
 
     fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
@@ -1243,6 +1215,18 @@ where
         self.0.serialize_value(value)
     }
 
+    fn serialize_entry<K: ?Sized, V: ?Sized>(
+        &mut self,
+        key: &K,
+        value: &V,
+    ) -> Result<(), Self::Error>
+    where
+        K: Serialize,
+        V: Serialize,
+    {
+        self.0.serialize_entry(key, value)
+    }
+
     fn end(self) -> Result<(), Self::Error> {
         Ok(())
     }

serde/src/private/size_hint.rs

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

serde/src/ser/fmt.rs

@@ -0,0 +1,174 @@
+use lib::*;
+use ser::{Error, Impossible, Serialize, Serializer};
+
+impl Error for fmt::Error {
+    fn custom<T: Display>(_msg: T) -> Self {
+        fmt::Error
+    }
+}
+
+macro_rules! fmt_primitives {
+    ($($f:ident: $t:ty,)*) => {
+        $(
+            fn $f(self, v: $t) -> fmt::Result {
+                Display::fmt(&v, self)
+            }
+        )*
+    };
+}
+
+/// ```edition2018
+/// use serde::Serialize;
+/// use std::fmt::{self, Display};
+///
+/// #[derive(Serialize)]
+/// #[serde(rename_all = "kebab-case")]
+/// pub enum MessageType {
+///     StartRequest,
+///     EndRequest,
+/// }
+///
+/// impl Display for MessageType {
+///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+///         self.serialize(f)
+///     }
+/// }
+/// ```
+impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
+    type Ok = ();
+    type Error = fmt::Error;
+    type SerializeSeq = Impossible<(), fmt::Error>;
+    type SerializeTuple = Impossible<(), fmt::Error>;
+    type SerializeTupleStruct = Impossible<(), fmt::Error>;
+    type SerializeTupleVariant = Impossible<(), fmt::Error>;
+    type SerializeMap = Impossible<(), fmt::Error>;
+    type SerializeStruct = Impossible<(), fmt::Error>;
+    type SerializeStructVariant = Impossible<(), fmt::Error>;
+
+    fmt_primitives! {
+        serialize_bool: bool,
+        serialize_i8: i8,
+        serialize_i16: i16,
+        serialize_i32: i32,
+        serialize_i64: i64,
+        serialize_u8: u8,
+        serialize_u16: u16,
+        serialize_u32: u32,
+        serialize_u64: u64,
+        serialize_f32: f32,
+        serialize_f64: f64,
+        serialize_char: char,
+        serialize_str: &str,
+        serialize_unit_struct: &'static str,
+    }
+
+    serde_if_integer128! {
+        fmt_primitives! {
+            serialize_i128: i128,
+            serialize_u128: u128,
+        }
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> fmt::Result {
+        Display::fmt(variant, self)
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
+    where
+        T: Serialize,
+    {
+        Serialize::serialize(value, self)
+    }
+
+    fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
+        Err(fmt::Error)
+    }
+
+    fn serialize_none(self) -> fmt::Result {
+        Err(fmt::Error)
+    }
+
+    fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
+    where
+        T: Serialize,
+    {
+        Err(fmt::Error)
+    }
+
+    fn serialize_unit(self) -> fmt::Result {
+        Err(fmt::Error)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> fmt::Result
+    where
+        T: Serialize,
+    {
+        Err(fmt::Error)
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
+    where
+        T: Display,
+    {
+        Display::fmt(value, self)
+    }
+}

serde/src/ser/impls.rs

@@ -239,7 +239,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(range_inclusive)]
+#[cfg(not(no_range_inclusive))]
 impl<Idx> Serialize for RangeInclusive<Idx>
 where
     Idx: Serialize,
@@ -258,7 +258,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(ops_bound, collections_bound))]
+#[cfg(any(not(no_ops_bound), all(feature = "std", not(no_collections_bound))))]
 impl<T> Serialize for Bound<T>
 where
     T: Serialize,
@@ -467,7 +467,7 @@ where
 macro_rules! nonzero_integers {
     ( $( $T: ident, )+ ) => {
         $(
-            #[cfg(num_nonzero)]
+            #[cfg(not(no_num_nonzero))]
             impl Serialize for num::$T {
                 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                 where
@@ -488,7 +488,7 @@ nonzero_integers! {
     NonZeroUsize,
 }
 
-#[cfg(num_nonzero_signed)]
+#[cfg(not(no_num_nonzero_signed))]
 nonzero_integers! {
     NonZeroI8,
     NonZeroI16,
@@ -504,7 +504,7 @@ serde_if_integer128! {
         NonZeroU128,
     }
 
-    #[cfg(num_nonzero_signed)]
+    #[cfg(not(no_num_nonzero_signed))]
     nonzero_integers! {
         NonZeroI128,
     }
@@ -591,7 +591,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(core_duration, feature = "std"))]
+#[cfg(any(feature = "std", not(no_core_duration)))]
 impl Serialize for Duration {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -616,7 +616,7 @@ impl Serialize for SystemTime {
         use super::SerializeStruct;
         let duration_since_epoch = self
             .duration_since(UNIX_EPOCH)
-            .expect("SystemTime must be later than UNIX_EPOCH");
+            .map_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()));
@@ -633,8 +633,7 @@ impl Serialize for SystemTime {
 #[cfg(feature = "std")]
 macro_rules! serialize_display_bounded_length {
     ($value:expr, $max:expr, $serializer:expr) => {{
-        #[allow(deprecated)]
-        let mut buffer: [u8; $max] = unsafe { mem::uninitialized() };
+        let mut buffer = [0u8; $max];
         let remaining_len = {
             let mut remaining = &mut buffer[..];
             write!(remaining, "{}", $value).unwrap();
@@ -646,7 +645,7 @@ macro_rules! serialize_display_bounded_length {
         // write! only provides fmt::Formatter to Display implementations, which
         // has methods write_str and write_char but no method to write arbitrary
         // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = unsafe { str::from_utf8_unchecked(written) };
+        let written_str = str::from_utf8(written).expect("must be valid UTF-8");
         $serializer.serialize_str(written_str)
     }};
 }
@@ -675,6 +674,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>
@@ -684,7 +729,14 @@ impl Serialize for net::Ipv4Addr {
         if serializer.is_human_readable() {
             const MAX_LEN: usize = 15;
             debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+            let mut buf = [b'.'; MAX_LEN];
+            let mut written = format_u8(self.octets()[0], &mut buf);
+            for oct in &self.octets()[1..] {
+                // Skip over delimiters that we initialized buf with
+                written += format_u8(*oct, &mut buf[written + 1..]) + 1;
+            }
+            // We've only written ASCII bytes to the buffer, so it is valid UTF-8
+            serializer.serialize_str(unsafe { str::from_utf8_unchecked(&buf[..written]) })
         } else {
             self.octets().serialize(serializer)
         }
@@ -754,10 +806,10 @@ impl Serialize for net::SocketAddrV6 {
         S: Serializer,
     {
         if serializer.is_human_readable() {
-            const MAX_LEN: usize = 47;
+            const MAX_LEN: usize = 58;
             debug_assert_eq!(
                 MAX_LEN,
-                "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()
+                "[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]:65000".len()
             );
             serialize_display_bounded_length!(self, MAX_LEN, serializer)
         } else {
@@ -825,7 +877,6 @@ impl Serialize for OsString {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 impl<T> Serialize for Wrapping<T>
 where
     T: Serialize,
@@ -839,7 +890,7 @@ where
     }
 }
 
-#[cfg(core_reverse)]
+#[cfg(not(no_core_reverse))]
 impl<T> Serialize for Reverse<T>
 where
     T: Serialize,
@@ -855,7 +906,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
     ($($ty:ident)*) => {
         $(
@@ -864,6 +915,7 @@ macro_rules! atomic_impl {
                 where
                     S: Serializer,
                 {
+                    // Matches the atomic ordering used in libcore for the Debug impl
                     self.load(Ordering::SeqCst).serialize(serializer)
                 }
             }
@@ -871,14 +923,14 @@ macro_rules! atomic_impl {
     }
 }
 
-#[cfg(all(feature = "std", std_atomic))]
+#[cfg(all(feature = "std", not(no_std_atomic)))]
 atomic_impl! {
     AtomicBool
     AtomicI8 AtomicI16 AtomicI32 AtomicIsize
     AtomicU8 AtomicU16 AtomicU32 AtomicUsize
 }
 
-#[cfg(all(feature = "std", std_atomic64))]
+#[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
     AtomicI64 AtomicU64
 }

serde/src/ser/impossible.rs

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

serde/src/ser/mod.rs

@@ -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/TyOverby/bincode
+//! [`bincode`]: https://github.com/bincode-org/bincode
 //! [`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
@@ -109,11 +109,19 @@
 
 use lib::*;
 
+mod fmt;
 mod impls;
 mod impossible;
 
 pub use self::impossible::Impossible;
 
+#[cfg(feature = "std")]
+#[doc(no_inline)]
+pub use std::error::Error as StdError;
+#[cfg(not(feature = "std"))]
+#[doc(no_inline)]
+pub use std_error::Error as StdError;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! declare_error_trait {
@@ -172,7 +180,7 @@ macro_rules! declare_error_trait {
 }
 
 #[cfg(feature = "std")]
-declare_error_trait!(Error: Sized + error::Error);
+declare_error_trait!(Error: Sized + StdError);
 
 #[cfg(not(feature = "std"))]
 declare_error_trait!(Error: Sized + Debug + Display);
@@ -703,7 +711,7 @@ pub trait Serializer: Sized {
     ///
     /// ```edition2018
     /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::private::ser::Error;
+    /// # use serde::__private::doc::Error;
     /// #
     /// # struct MySerializer;
     /// #
@@ -1270,10 +1278,21 @@ pub trait Serializer: Sized {
         <I as IntoIterator>::Item: Serialize,
     {
         let iter = iter.into_iter();
-        let mut serializer = try!(self.serialize_seq(iter.len_hint()));
-        for item in iter {
-            try!(serializer.serialize_element(&item));
+        let mut serializer = try!(self.serialize_seq(iterator_len_hint(&iter)));
+
+        #[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()
     }
 
@@ -1310,10 +1329,21 @@ pub trait Serializer: Sized {
         I: IntoIterator<Item = (K, V)>,
     {
         let iter = iter.into_iter();
-        let mut serializer = try!(self.serialize_map(iter.len_hint()));
-        for (key, value) in iter {
-            try!(serializer.serialize_entry(&key, &value));
+        let mut serializer = try!(self.serialize_map(iterator_len_hint(&iter)));
+
+        #[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()
     }
 
@@ -1352,10 +1382,7 @@ pub trait Serializer: Sized {
     where
         T: Display,
     {
-        use lib::fmt::Write;
-        let mut string = String::new();
-        write!(string, "{}", value).unwrap();
-        self.serialize_str(&string)
+        self.serialize_str(&value.to_string())
     }
 
     /// Serialize a string produced by an implementation of `Display`.
@@ -1948,35 +1975,6 @@ pub trait SerializeStructVariant {
     fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
-trait LenHint: Iterator {
-    fn len_hint(&self) -> Option<usize>;
-}
-
-impl<I> LenHint for I
-where
-    I: Iterator,
-{
-    #[cfg(not(feature = "unstable"))]
-    fn len_hint(&self) -> Option<usize> {
-        iterator_len_hint(self)
-    }
-
-    #[cfg(feature = "unstable")]
-    default fn len_hint(&self) -> Option<usize> {
-        iterator_len_hint(self)
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl<I> LenHint for I
-where
-    I: ExactSizeIterator,
-{
-    fn len_hint(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
 fn iterator_len_hint<I>(iter: &I) -> Option<usize>
 where
     I: Iterator,

serde/src/std_error.rs

@@ -0,0 +1,48 @@
+use lib::{Debug, Display};
+
+/// Either a re-export of std::error::Error or a new identical trait, depending
+/// on whether Serde's "std" feature is enabled.
+///
+/// Serde's error traits [`serde::ser::Error`] and [`serde::de::Error`] require
+/// [`std::error::Error`] as a supertrait, but only when Serde is built with
+/// "std" enabled. Data formats that don't care about no\_std support should
+/// generally provide their error types with a `std::error::Error` impl
+/// directly:
+///
+/// ```edition2018
+/// #[derive(Debug)]
+/// struct MySerError {...}
+///
+/// impl serde::ser::Error for MySerError {...}
+///
+/// impl std::fmt::Display for MySerError {...}
+///
+/// // We don't support no_std!
+/// impl std::error::Error for MySerError {}
+/// ```
+///
+/// Data formats that *do* support no\_std may either have a "std" feature of
+/// their own:
+///
+/// ```toml
+/// [features]
+/// std = ["serde/std"]
+/// ```
+///
+/// ```edition2018
+/// #[cfg(feature = "std")]
+/// impl std::error::Error for MySerError {}
+/// ```
+///
+/// ... or else provide the std Error impl unconditionally via Serde's
+/// re-export:
+///
+/// ```edition2018
+/// impl serde::ser::StdError for MySerError {}
+/// ```
+pub trait Error: Debug + Display {
+    /// The underlying cause of this error, if any.
+    fn source(&self) -> Option<&(Error + 'static)> {
+        None
+    }
+}

serde_derive/.clippy.toml

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

serde_derive/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "serde_derive"
-version = "1.0.99" # remember to update html_root_url
+version = "1.0.140" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+rust-version = "1.31"
 license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
 homepage = "https://serde.rs"
@@ -9,11 +10,7 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://serde.rs/derive.html"
 keywords = ["serde", "serialization", "no_std"]
 readme = "crates-io.md"
-include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-
-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [features]
 default = []
@@ -26,7 +23,10 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0", features = ["visit"] }
+syn = "1.0.90"
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

serde_derive/build.rs

@@ -0,0 +1,36 @@
+use std::env;
+use std::process::Command;
+use std::str;
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+    let minor = match rustc_minor_version() {
+        Some(minor) => minor,
+        None => return,
+    };
+
+    // Underscore const names stabilized in Rust 1.37:
+    // https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html#using-unnamed-const-items-for-macros
+    if minor < 37 {
+        println!("cargo:rustc-cfg=no_underscore_consts");
+    }
+
+    // The ptr::addr_of! macro stabilized in Rust 1.51:
+    // https://blog.rust-lang.org/2021/03/25/Rust-1.51.0.html#stabilized-apis
+    if minor < 51 {
+        println!("cargo:rustc-cfg=no_ptr_addr_of");
+    }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+    let rustc = env::var_os("RUSTC")?;
+    let output = Command::new(rustc).arg("--version").output().ok()?;
+    let version = str::from_utf8(&output.stdout).ok()?;
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+    pieces.next()?.parse().ok()
+}

serde_derive/src/bound.rs

@@ -2,10 +2,9 @@ use std::collections::HashSet;
 
 use syn;
 use syn::punctuated::{Pair, Punctuated};
-use syn::visit::{self, Visit};
 
 use internals::ast::{Container, Data};
-use internals::attr;
+use internals::{attr, ungroup};
 
 use proc_macro2::Span;
 
@@ -17,8 +16,8 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
         params: generics
             .params
             .iter()
-            .map(|param| match *param {
-                syn::GenericParam::Type(ref param) => syn::GenericParam::Type(syn::TypeParam {
+            .map(|param| match param {
+                syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
                     eq_token: None,
                     default: None,
                     ..param.clone()
@@ -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);
@@ -63,8 +62,8 @@ pub fn with_where_predicates_from_variants(
     generics: &syn::Generics,
     from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
 ) -> syn::Generics {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return generics.clone();
         }
@@ -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,10 +111,11 @@ 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(ref ty) = field.ty {
-                if let Some(Pair::Punctuated(ref t, _)) = ty.path.segments.pairs().next() {
+            if let syn::Type::Path(ty) = ungroup(&field.ty) {
+                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
                     if self.all_type_params.contains(&t.ident) {
                         self.associated_type_usage.push(ty);
                     }
@@ -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.
@@ -156,12 +245,12 @@ pub fn with_bound(
         .collect();
 
     let mut visitor = FindTyParams {
-        all_type_params: all_type_params,
+        all_type_params,
         relevant_type_params: HashSet::new(),
         associated_type_usage: Vec::new(),
     };
-    match cont.data {
-        Data::Enum(ref variants) => {
+    match &cont.data {
+        Data::Enum(variants) => {
             for variant in variants.iter() {
                 let relevant_fields = variant
                     .fields
@@ -172,7 +261,7 @@ pub fn with_bound(
                 }
             }
         }
-        Data::Struct(_, ref fields) => {
+        Data::Struct(_, fields) => {
             for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
                 visitor.visit_field(field.original);
             }
@@ -255,11 +344,11 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
     let params = Some(syn::GenericParam::Lifetime(def))
         .into_iter()
         .chain(generics.params.iter().cloned().map(|mut param| {
-            match param {
-                syn::GenericParam::Lifetime(ref mut param) => {
+            match &mut param {
+                syn::GenericParam::Lifetime(param) => {
                     param.bounds.push(bound.clone());
                 }
-                syn::GenericParam::Type(ref mut param) => {
+                syn::GenericParam::Type(param) => {
                     param
                         .bounds
                         .push(syn::TypeParamBound::Lifetime(bound.clone()));
@@ -271,7 +360,7 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
         .collect();
 
     syn::Generics {
-        params: params,
+        params,
         ..generics.clone()
     }
 }
@@ -291,14 +380,14 @@ fn type_of_item(cont: &Container) -> syn::Type {
                             .generics
                             .params
                             .iter()
-                            .map(|param| match *param {
-                                syn::GenericParam::Type(ref param) => {
+                            .map(|param| match param {
+                                syn::GenericParam::Type(param) => {
                                     syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
                                         qself: None,
                                         path: param.ident.clone().into(),
                                     }))
                                 }
-                                syn::GenericParam::Lifetime(ref param) => {
+                                syn::GenericParam::Lifetime(param) => {
                                     syn::GenericArgument::Lifetime(param.lifetime.clone())
                                 }
                                 syn::GenericParam::Const(_) => {

serde_derive/src/dummy.rs

@@ -1,4 +1,5 @@
-use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, TokenStream};
+use quote::format_ident;
 
 use syn;
 use try;
@@ -11,24 +12,24 @@ pub fn wrap_in_const(
 ) -> TokenStream {
     let try_replacement = try::replacement();
 
-    let dummy_const = Ident::new(
-        &format!("_IMPL_{}_FOR_{}", trait_, unraw(ty)),
-        Span::call_site(),
-    );
+    let dummy_const = if cfg!(no_underscore_consts) {
+        format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
+    } else {
+        format_ident!("_")
+    };
 
     let use_serde = match serde_path {
         Some(path) => quote! {
             use #path as _serde;
         },
         None => quote! {
-            #[allow(unknown_lints)]
-            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
-            #[allow(rust_2018_idioms)]
+            #[allow(unused_extern_crates, clippy::useless_attribute)]
             extern crate serde as _serde;
         },
     };
 
     quote! {
+        #[doc(hidden)]
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
         const #dummy_const: () = {
             #use_serde

serde_derive/src/fragment.rs

@@ -27,9 +27,9 @@ macro_rules! quote_block {
 pub struct Expr(pub Fragment);
 impl ToTokens for Expr {
     fn to_tokens(&self, out: &mut TokenStream) {
-        match self.0 {
-            Fragment::Expr(ref expr) => expr.to_tokens(out),
-            Fragment::Block(ref block) => {
+        match &self.0 {
+            Fragment::Expr(expr) => expr.to_tokens(out),
+            Fragment::Block(block) => {
                 token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
@@ -40,9 +40,9 @@ impl ToTokens for Expr {
 pub struct Stmts(pub Fragment);
 impl ToTokens for Stmts {
     fn to_tokens(&self, out: &mut TokenStream) {
-        match self.0 {
-            Fragment::Expr(ref expr) => expr.to_tokens(out),
-            Fragment::Block(ref block) => block.to_tokens(out),
+        match &self.0 {
+            Fragment::Expr(expr) => expr.to_tokens(out),
+            Fragment::Block(block) => block.to_tokens(out),
         }
     }
 }
@@ -52,12 +52,12 @@ impl ToTokens for Stmts {
 pub struct Match(pub Fragment);
 impl ToTokens for Match {
     fn to_tokens(&self, out: &mut TokenStream) {
-        match self.0 {
-            Fragment::Expr(ref expr) => {
+        match &self.0 {
+            Fragment::Expr(expr) => {
                 expr.to_tokens(out);
                 <Token![,]>::default().to_tokens(out);
             }
-            Fragment::Block(ref block) => {
+            Fragment::Block(block) => {
                 token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
@@ -66,9 +66,9 @@ impl ToTokens for Match {
 
 impl AsRef<TokenStream> for Fragment {
     fn as_ref(&self) -> &TokenStream {
-        match *self {
-            Fragment::Expr(ref expr) => expr,
-            Fragment::Block(ref block) => block,
+        match self {
+            Fragment::Expr(expr) => expr,
+            Fragment::Block(block) => block,
         }
     }
 }

serde_derive/src/internals/ast.rs

@@ -23,7 +23,7 @@ pub struct Container<'a> {
 
 /// The fields of a struct or enum.
 ///
-/// Analagous to `syn::Data`.
+/// Analogous to `syn::Data`.
 pub enum Data<'a> {
     Enum(Vec<Variant<'a>>),
     Struct(Style, Vec<Field<'a>>),
@@ -67,11 +67,9 @@ impl<'a> Container<'a> {
     ) -> Option<Container<'a>> {
         let mut attrs = attr::Container::from_ast(cx, item);
 
-        let mut data = match item.data {
-            syn::Data::Enum(ref data) => {
-                Data::Enum(enum_from_ast(cx, &data.variants, attrs.default()))
-            }
-            syn::Data::Struct(ref data) => {
+        let mut data = match &item.data {
+            syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants, attrs.default())),
+            syn::Data::Struct(data) => {
                 let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
                 Data::Struct(style, fields)
             }
@@ -82,8 +80,8 @@ impl<'a> Container<'a> {
         };
 
         let mut has_flatten = false;
-        match data {
-            Data::Enum(ref mut variants) => {
+        match &mut data {
+            Data::Enum(variants) => {
                 for variant in variants {
                     variant.attrs.rename_by_rules(attrs.rename_all_rules());
                     for field in &mut variant.fields {
@@ -96,7 +94,7 @@ impl<'a> Container<'a> {
                     }
                 }
             }
-            Data::Struct(_, ref mut fields) => {
+            Data::Struct(_, fields) => {
                 for field in fields {
                     if field.attrs.flatten() {
                         has_flatten = true;
@@ -112,8 +110,8 @@ impl<'a> Container<'a> {
 
         let mut item = Container {
             ident: item.ident.clone(),
-            attrs: attrs,
-            data: data,
+            attrs,
+            data,
             generics: &item.generics,
             original: item,
         };
@@ -124,11 +122,11 @@ impl<'a> Container<'a> {
 
 impl<'a> Data<'a> {
     pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
-        match *self {
-            Data::Enum(ref variants) => {
+        match self {
+            Data::Enum(variants) => {
                 Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
             }
-            Data::Struct(_, ref fields) => Box::new(fields.iter()),
+            Data::Struct(_, fields) => Box::new(fields.iter()),
         }
     }
 
@@ -150,9 +148,9 @@ fn enum_from_ast<'a>(
                 struct_from_ast(cx, &variant.fields, Some(&attrs), container_default);
             Variant {
                 ident: variant.ident.clone(),
-                attrs: attrs,
-                style: style,
-                fields: fields,
+                attrs,
+                style,
+                fields,
                 original: variant,
             }
         })
@@ -165,16 +163,16 @@ fn struct_from_ast<'a>(
     attrs: Option<&attr::Variant>,
     container_default: &attr::Default,
 ) -> (Style, Vec<Field<'a>>) {
-    match *fields {
-        syn::Fields::Named(ref fields) => (
+    match fields {
+        syn::Fields::Named(fields) => (
             Style::Struct,
             fields_from_ast(cx, &fields.named, attrs, container_default),
         ),
-        syn::Fields::Unnamed(ref fields) if fields.unnamed.len() == 1 => (
+        syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => (
             Style::Newtype,
             fields_from_ast(cx, &fields.unnamed, attrs, container_default),
         ),
-        syn::Fields::Unnamed(ref fields) => (
+        syn::Fields::Unnamed(fields) => (
             Style::Tuple,
             fields_from_ast(cx, &fields.unnamed, attrs, container_default),
         ),
@@ -192,8 +190,8 @@ fn fields_from_ast<'a>(
         .iter()
         .enumerate()
         .map(|(i, field)| Field {
-            member: match field.ident {
-                Some(ref ident) => syn::Member::Named(ident.clone()),
+            member: match &field.ident {
+                Some(ident) => syn::Member::Named(ident.clone()),
                 None => syn::Member::Unnamed(i.into()),
             },
             attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),

serde_derive/src/internals/case.rs

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

serde_derive/src/internals/check.rs

@@ -1,6 +1,6 @@
 use internals::ast::{Container, Data, Field, Style};
 use internals::attr::{Identifier, TagType};
-use internals::{Ctxt, Derive};
+use internals::{ungroup, Ctxt, Derive};
 use syn::{Member, Type};
 
 /// Cross-cutting checks that require looking at more than a single attrs
@@ -32,8 +32,7 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
             if cont.data.has_getter() && cont.attrs.remote().is_none() {
                 cx.error_spanned_by(
                     cont.original,
-                    "#[serde(getter = \"...\")] can only be used in structs \
-                     that have #[serde(remote = \"...\")]",
+                    "#[serde(getter = \"...\")] can only be used in structs that have #[serde(remote = \"...\")]",
                 );
             }
         }
@@ -42,17 +41,17 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
 
 /// Flattening has some restrictions we can test.
 fn check_flatten(cx: &Ctxt, cont: &Container) {
-    match cont.data {
-        Data::Enum(ref variants) => {
+    match &cont.data {
+        Data::Enum(variants) => {
             for variant in variants {
                 for field in &variant.fields {
                     check_flatten_field(cx, variant.style, field);
                 }
             }
         }
-        Data::Struct(style, ref fields) => {
+        Data::Struct(style, fields) => {
             for field in fields {
-                check_flatten_field(cx, style, field);
+                check_flatten_field(cx, *style, field);
             }
         }
     }
@@ -86,8 +85,8 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
 /// `field_identifier` all but possibly one variant must be unit variants. The
 /// last variant may be a newtype variant which is an implicit "other" case.
 fn check_identifier(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return;
         }
@@ -170,8 +169,8 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
 /// Skip-(de)serializing attributes are not allowed on variants marked
 /// (de)serialize_with.
 fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return;
         }
@@ -183,8 +182,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                 cx.error_spanned_by(
                     variant.original,
                     format!(
-                        "variant `{}` cannot have both #[serde(serialize_with)] and \
-                         #[serde(skip_serializing)]",
+                        "variant `{}` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]",
                         variant.ident
                     ),
                 );
@@ -197,8 +195,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                     cx.error_spanned_by(
                         variant.original,
                         format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and \
-                             a field {} marked with #[serde(skip_serializing)]",
+                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing)]",
                             variant.ident, member
                         ),
                     );
@@ -208,8 +205,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                     cx.error_spanned_by(
                         variant.original,
                         format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and \
-                             a field {} marked with #[serde(skip_serializing_if)]",
+                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing_if)]",
                             variant.ident, member
                         ),
                     );
@@ -222,8 +218,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                 cx.error_spanned_by(
                     variant.original,
                     format!(
-                        "variant `{}` cannot have both #[serde(deserialize_with)] and \
-                         #[serde(skip_deserializing)]",
+                        "variant `{}` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]",
                         variant.ident
                     ),
                 );
@@ -236,8 +231,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                     cx.error_spanned_by(
                         variant.original,
                         format!(
-                            "variant `{}` cannot have both #[serde(deserialize_with)] \
-                             and a field {} marked with #[serde(skip_deserializing)]",
+                            "variant `{}` cannot have both #[serde(deserialize_with)] and a field {} marked with #[serde(skip_deserializing)]",
                             variant.ident, member
                         ),
                     );
@@ -252,13 +246,13 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
 /// duplicate keys in the serialized output and/or ambiguity in
 /// the to-be-deserialized input.
 fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => return,
     };
 
-    let tag = match *cont.attrs.tag() {
-        TagType::Internal { ref tag } => tag.as_str(),
+    let tag = match cont.attrs.tag() {
+        TagType::Internal { tag } => tag.as_str(),
         TagType::External | TagType::Adjacent { .. } | TagType::None => return,
     };
 
@@ -266,7 +260,7 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
         cx.error_spanned_by(
             cont.original,
             format!("variant field name `{}` conflicts with internal tag", tag),
-        )
+        );
     };
 
     for variant in variants {
@@ -299,11 +293,8 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
 /// In the case of adjacently-tagged enums, the type and the
 /// contents tag must differ, for the same reason.
 fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
-    let (type_tag, content_tag) = match *cont.attrs.tag() {
-        TagType::Adjacent {
-            ref tag,
-            ref content,
-        } => (tag, content),
+    let (type_tag, content_tag) = match cont.attrs.tag() {
+        TagType::Adjacent { tag, content } => (tag, content),
         TagType::Internal { .. } | TagType::External | TagType::None => return,
     };
 
@@ -345,7 +336,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
         );
     }
 
-    let fields = match cont.data {
+    let fields = match &mut cont.data {
         Data::Enum(_) => {
             cx.error_spanned_by(
                 cont.original,
@@ -360,7 +351,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
             );
             return;
         }
-        Data::Struct(_, ref mut fields) => fields,
+        Data::Struct(_, fields) => fields,
     };
 
     let mut transparent_field = None;
@@ -398,14 +389,14 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
 }
 
 fn member_message(member: &Member) -> String {
-    match *member {
-        Member::Named(ref ident) => format!("`{}`", ident),
-        Member::Unnamed(ref i) => format!("#{}", i.index),
+    match member {
+        Member::Named(ident) => format!("`{}`", ident),
+        Member::Unnamed(i) => format!("#{}", i.index),
     }
 }
 
 fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ref ty) = *field.ty {
+    if let Type::Path(ty) = ungroup(field.ty) {
         if let Some(seg) = ty.path.segments.last() {
             if seg.ident == "PhantomData" {
                 return false;

serde_derive/src/internals/ctxt.rs

@@ -38,6 +38,11 @@ impl Ctxt {
             .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
     }
 
+    /// Add one of Syn's parse errors.
+    pub fn syn_error(&self, err: syn::Error) {
+        self.errors.borrow_mut().as_mut().unwrap().push(err);
+    }
+
     /// Consume this object, producing a formatted error string if there are errors.
     pub fn check(self) -> Result<(), Vec<syn::Error>> {
         let errors = self.errors.borrow_mut().take().unwrap();

serde_derive/src/internals/mod.rs

@@ -4,12 +4,25 @@ 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;
+
 #[derive(Copy, Clone)]
 pub enum Derive {
     Serialize,
     Deserialize,
 }
+
+pub fn ungroup(mut ty: &Type) -> &Type {
+    while let Type::Group(group) = ty {
+        ty = &group.elem;
+    }
+    ty
+}

serde_derive/src/internals/receiver.rs

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

serde_derive/src/internals/respan.rs

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

serde_derive/src/internals/symbol.rs

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

serde_derive/src/lib.rs

@@ -13,44 +13,55 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.99")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.140")]
 #![allow(unknown_lints, bare_trait_objects)]
-#![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(
-        cognitive_complexity,
-        enum_variant_names,
-        needless_pass_by_value,
-        redundant_field_names,
-        too_many_arguments,
-        trivially_copy_pass_by_ref,
-        used_underscore_binding,
-    )
+#![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,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::used_underscore_binding,
+    clippy::wildcard_in_or_patterns,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+    clippy::unnested_or_patterns,
 )]
 // Ignored clippy_pedantic lints
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        cast_possible_truncation,
-        checked_conversions,
-        doc_markdown,
-        enum_glob_use,
-        filter_map,
-        indexing_slicing,
-        items_after_statements,
-        match_same_arms,
-        module_name_repetitions,
-        similar_names,
-        single_match_else,
-        unseparated_literal_suffix,
-        use_self,
-    )
+#![allow(
+    clippy::cast_possible_truncation,
+    clippy::checked_conversions,
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::indexing_slicing,
+    clippy::items_after_statements,
+    clippy::let_underscore_drop,
+    clippy::manual_assert,
+    clippy::map_err_ignore,
+    clippy::match_same_arms,
+    // 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,
+    clippy::similar_names,
+    clippy::single_match_else,
+    clippy::struct_excessive_bools,
+    clippy::too_many_lines,
+    clippy::unseparated_literal_suffix,
+    clippy::unused_self,
+    clippy::use_self,
+    clippy::wildcard_imports
 )]
-// The `quote!` macro requires deep recursion.
-#![recursion_limit = "512"]
+#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]
 
 #[macro_use]
 extern crate quote;
@@ -78,16 +89,16 @@ mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&input)
+    let mut input = parse_macro_input!(input as DeriveInput);
+    ser::expand_derive_serialize(&mut input)
         .unwrap_or_else(to_compile_errors)
         .into()
 }
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&input)
+    let mut input = parse_macro_input!(input as DeriveInput);
+    de::expand_derive_deserialize(&mut input)
         .unwrap_or_else(to_compile_errors)
         .into()
 }

serde_derive/src/pretend.rs

@@ -1,7 +1,7 @@
-use proc_macro2::{Span, TokenStream};
-use syn::Ident;
+use proc_macro2::TokenStream;
+use quote::format_ident;
 
-use internals::ast::{Container, Data, Field, Style};
+use internals::ast::{Container, Data, Field, Style, Variant};
 
 // Suppress dead_code warnings that would otherwise appear when using a remote
 // derive. Other than this pretend code, a struct annotated with remote derive
@@ -20,8 +20,8 @@ use internals::ast::{Container, Data, Field, Style};
 //     8 | enum EnumDef { V }
 //       |                ^
 //
-pub fn pretend_used(cont: &Container) -> TokenStream {
-    let pretend_fields = pretend_fields_used(cont);
+pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
+    let pretend_fields = pretend_fields_used(cont, is_packed);
     let pretend_variants = pretend_variants_used(cont);
 
     quote! {
@@ -32,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(ref 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, ref 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) => {}
             )*
             _ => {}
         }
@@ -93,8 +161,8 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
 //     }
 //
 fn pretend_variants_used(cont: &Container) -> TokenStream {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return quote!();
         }
@@ -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),* })
-}

serde_derive/src/ser.rs

@@ -6,10 +6,14 @@ use bound;
 use dummy;
 use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt, Derive};
+use internals::{attr, replace_receiver, Ctxt, Derive};
 use pretend;
 
-pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_serialize(
+    input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+    replace_receiver(input);
+
     let ctxt = Ctxt::new();
     let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
         Some(cont) => cont,
@@ -26,10 +30,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 +46,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,
                 {
@@ -87,6 +91,9 @@ struct Parameters {
 
     /// Type has a `serde(remote = "...")` attribute.
     is_remote: bool,
+
+    /// Type has a repr(packed) attribute.
+    is_packed: bool,
 }
 
 impl Parameters {
@@ -103,13 +110,16 @@ impl Parameters {
             None => cont.ident.clone().into(),
         };
 
+        let is_packed = cont.attrs.is_packed();
+
         let generics = build_generics(cont);
 
         Parameters {
-            self_var: self_var,
-            this: this,
-            generics: generics,
-            is_remote: is_remote,
+            self_var,
+            this,
+            generics,
+            is_remote,
+            is_packed,
         }
     }
 
@@ -164,15 +174,13 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
     } else if let Some(type_into) = cont.attrs.type_into() {
         serialize_into(params, type_into)
     } else {
-        match cont.data {
-            Data::Enum(ref variants) => serialize_enum(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, ref fields) => {
-                serialize_struct(params, fields, &cont.attrs)
-            }
-            Data::Struct(Style::Tuple, ref fields) => {
+        match &cont.data {
+            Data::Enum(variants) => serialize_enum(params, variants, &cont.attrs),
+            Data::Struct(Style::Struct, fields) => serialize_struct(params, fields, &cont.attrs),
+            Data::Struct(Style::Tuple, fields) => {
                 serialize_tuple_struct(params, fields, &cont.attrs)
             }
-            Data::Struct(Style::Newtype, ref fields) => {
+            Data::Struct(Style::Newtype, fields) => {
                 serialize_newtype_struct(params, &fields[0], &cont.attrs)
             }
             Data::Struct(Style::Unit, _) => serialize_unit_struct(&cont.attrs),
@@ -181,8 +189,8 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
 }
 
 fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
-    let fields = match cont.data {
-        Data::Struct(_, ref fields) => fields,
+    let fields = match &cont.data {
+        Data::Struct(_, fields) => fields,
         Data::Enum(_) => unreachable!(),
     };
 
@@ -207,7 +215,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)
     }
 }
@@ -259,7 +267,7 @@ fn serialize_tuple_struct(
     let mut serialized_fields = fields
         .iter()
         .enumerate()
-        .filter(|&(_, ref field)| !field.attrs.skip_serializing())
+        .filter(|(_, field)| !field.attrs.skip_serializing())
         .peekable();
 
     let let_mut = mut_if(serialized_fields.peek().is_some());
@@ -296,8 +304,8 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
 }
 
 fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTrait) -> TokenStream {
-    match *cattrs.tag() {
-        attr::TagType::Internal { ref tag } => {
+    match cattrs.tag() {
+        attr::TagType::Internal { tag } => {
             let type_name = cattrs.name().serialize_name();
             let func = struct_trait.serialize_field(Span::call_site());
             quote! {
@@ -368,7 +376,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() {
@@ -382,7 +390,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! {
@@ -429,7 +437,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!(),
@@ -467,17 +475,16 @@ fn serialize_variant(
             }
         };
 
-        let body = Match(match *cattrs.tag() {
+        let body = Match(match cattrs.tag() {
             attr::TagType::External => {
                 serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
             }
-            attr::TagType::Internal { ref tag } => {
+            attr::TagType::Internal { tag } => {
                 serialize_internally_tagged_variant(params, variant, cattrs, tag)
             }
-            attr::TagType::Adjacent {
-                ref tag,
-                ref content,
-            } => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content),
+            attr::TagType::Adjacent { tag, content } => {
+                serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content)
+            }
             attr::TagType::None => serialize_untagged_variant(params, variant, cattrs),
         });
 
@@ -509,7 +516,7 @@ fn serialize_externally_tagged_variant(
         };
     }
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             quote_expr! {
                 _serde::Serializer::serialize_unit_variant(
@@ -541,17 +548,17 @@ fn serialize_externally_tagged_variant(
         }
         Style::Tuple => serialize_tuple_variant(
             TupleVariant::ExternallyTagged {
-                type_name: type_name,
-                variant_index: variant_index,
-                variant_name: variant_name,
+                type_name,
+                variant_index,
+                variant_name,
             },
             params,
             &variant.fields,
         ),
         Style::Struct => serialize_struct_variant(
             StructVariant::ExternallyTagged {
-                variant_index: variant_index,
-                variant_name: variant_name,
+                variant_index,
+                variant_name,
             },
             params,
             &variant.fields,
@@ -575,7 +582,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,
@@ -586,7 +593,7 @@ fn serialize_internally_tagged_variant(
         };
     }
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             quote_block! {
                 let mut __struct = try!(_serde::Serializer::serialize_struct(
@@ -604,7 +611,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,
@@ -617,10 +624,7 @@ fn serialize_internally_tagged_variant(
             }
         }
         Style::Struct => serialize_struct_variant(
-            StructVariant::InternallyTagged {
-                tag: tag,
-                variant_name: variant_name,
-            },
+            StructVariant::InternallyTagged { tag, variant_name },
             params,
             &variant.fields,
             &type_name,
@@ -646,7 +650,7 @@ fn serialize_adjacently_tagged_variant(
             _serde::Serialize::serialize(#ser, __serializer)
         }
     } else {
-        match variant.style {
+        match effective_style(variant) {
             Style::Unit => {
                 return quote_block! {
                     let mut __struct = try!(_serde::Serializer::serialize_struct(
@@ -715,14 +719,16 @@ 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 #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,
             {
+                // Elements that have skip_serializing will be unused.
+                #[allow(unused_variables)]
                 let (#(#fields_ident,)*) = self.data;
                 #inner
             }
@@ -735,7 +741,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 #ty_generics>,
             }));
         _serde::ser::SerializeStruct::end(__struct)
     }
@@ -753,7 +759,7 @@ fn serialize_untagged_variant(
         };
     }
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             quote_expr! {
                 _serde::Serializer::serialize_unit(__serializer)
@@ -804,7 +810,7 @@ fn serialize_tuple_variant(
     let mut serialized_fields = fields
         .iter()
         .enumerate()
-        .filter(|&(_, ref field)| !field.attrs.skip_serializing())
+        .filter(|(_, field)| !field.attrs.skip_serializing())
         .peekable();
 
     let let_mut = mut_if(serialized_fields.peek().is_some());
@@ -871,9 +877,9 @@ fn serialize_struct_variant<'a>(
     }
 
     let struct_trait = match context {
-        StructVariant::ExternallyTagged { .. } => (StructTrait::SerializeStructVariant),
+        StructVariant::ExternallyTagged { .. } => StructTrait::SerializeStructVariant,
         StructVariant::InternallyTagged { .. } | StructVariant::Untagged => {
-            (StructTrait::SerializeStruct)
+            StructTrait::SerializeStruct
         }
     };
 
@@ -976,18 +982,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 #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)
                     }
@@ -1000,7 +1006,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 #ty_generics>,
                     })
             }
         }
@@ -1008,7 +1014,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,
@@ -1022,7 +1028,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)
             }
@@ -1039,7 +1045,7 @@ fn serialize_tuple_struct_visitor(
     fields
         .iter()
         .enumerate()
-        .filter(|&(_, ref field)| !field.attrs.skip_serializing())
+        .filter(|(_, field)| !field.attrs.skip_serializing())
         .map(|(i, field)| {
             let mut field_expr = if is_enum {
                 let id = Ident::new(&format!("__field{}", i), Span::call_site());
@@ -1093,7 +1099,7 @@ fn serialize_struct_visitor(
             let mut field_expr = if is_enum {
                 quote!(#member)
             } else {
-                get_member(params, field, &member)
+                get_member(params, field, member)
             };
 
             let key_expr = field.attrs.name().serialize_name();
@@ -1111,7 +1117,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);
@@ -1163,9 +1169,9 @@ fn wrap_serialize_variant_with(
         .fields
         .iter()
         .map(|field| {
-            let id = match field.member {
-                Member::Named(ref ident) => ident.clone(),
-                Member::Unnamed(ref member) => {
+            let id = match &field.member {
+                Member::Named(ident) => ident.clone(),
+                Member::Unnamed(member) => {
                     Ident::new(&format!("__field{}", member.index), Span::call_site())
                 }
             };
@@ -1206,11 +1212,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 #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,
             {
@@ -1220,7 +1226,7 @@ fn wrap_serialize_with(
 
         &__SerializeWith {
             values: (#(#field_exprs, )*),
-            phantom: _serde::export::PhantomData::<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
         }
     })
 }
@@ -1242,15 +1248,25 @@ fn mut_if(is_mut: bool) -> Option<TokenStream> {
 fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStream {
     let self_var = &params.self_var;
     match (params.is_remote, field.attrs.getter()) {
-        (false, None) => quote!(&#self_var.#member),
+        (false, None) => {
+            if params.is_packed {
+                quote!(&{#self_var.#member})
+            } else {
+                quote!(&#self_var.#member)
+            }
+        }
         (true, None) => {
-            let inner = quote!(&#self_var.#member);
+            let inner = if params.is_packed {
+                quote!(&{#self_var.#member})
+            } else {
+                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");
@@ -1258,6 +1274,13 @@ fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStrea
     }
 }
 
+fn effective_style(variant: &Variant) -> Style {
+    match variant.style {
+        Style::Newtype if variant.fields[0].attrs.skip_serializing() => Style::Unit,
+        other => other,
+    }
+}
+
 enum StructTrait {
     SerializeMap,
     SerializeStruct,
@@ -1267,9 +1290,15 @@ enum StructTrait {
 impl StructTrait {
     fn serialize_field(&self, span: Span) -> TokenStream {
         match *self {
-            StructTrait::SerializeMap => quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry),
-            StructTrait::SerializeStruct => quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field),
-            StructTrait::SerializeStructVariant => quote_spanned!(span=> _serde::ser::SerializeStructVariant::serialize_field),
+            StructTrait::SerializeMap => {
+                quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry)
+            }
+            StructTrait::SerializeStruct => {
+                quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field)
+            }
+            StructTrait::SerializeStructVariant => {
+                quote_spanned!(span=> _serde::ser::SerializeStructVariant::serialize_field)
+            }
         }
     }
 
@@ -1295,9 +1324,15 @@ enum TupleTrait {
 impl TupleTrait {
     fn serialize_element(&self, span: Span) -> TokenStream {
         match *self {
-            TupleTrait::SerializeTuple => quote_spanned!(span=> _serde::ser::SerializeTuple::serialize_element),
-            TupleTrait::SerializeTupleStruct => quote_spanned!(span=> _serde::ser::SerializeTupleStruct::serialize_field),
-            TupleTrait::SerializeTupleVariant => quote_spanned!(span=> _serde::ser::SerializeTupleVariant::serialize_field),
+            TupleTrait::SerializeTuple => {
+                quote_spanned!(span=> _serde::ser::SerializeTuple::serialize_element)
+            }
+            TupleTrait::SerializeTupleStruct => {
+                quote_spanned!(span=> _serde::ser::SerializeTupleStruct::serialize_field)
+            }
+            TupleTrait::SerializeTupleVariant => {
+                quote_spanned!(span=> _serde::ser::SerializeTupleVariant::serialize_field)
+            }
         }
     }
 }

serde_derive/src/try.rs

@@ -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);
                     }
                 }
             }

serde_derive_internals/.clippy.toml

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

serde_derive_internals/Cargo.toml

@@ -1,23 +1,23 @@
 [package]
 name = "serde_derive_internals"
-version = "0.24.1" # 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>"]
+rust-version = "1.31"
 license = "MIT OR Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.rs/serde_derive_internals"
 keywords = ["serde", "serialization"]
-include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [lib]
 path = "lib.rs"
 
 [dependencies]
-proc-macro2 = "0.4"
-quote = "0.6.3"
-syn = { version = "0.15", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "1.0.90", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
 
-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/build.rs

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

serde_derive_internals/lib.rs

@@ -1,13 +1,40 @@
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.24.1")]
+#![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
-    )
+// Ignored clippy lints
+#![allow(
+    clippy::cognitive_complexity,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
+    clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
+    clippy::manual_map,
+    clippy::missing_panics_doc,
+    clippy::redundant_field_names,
+    clippy::result_unit_err,
+    clippy::should_implement_trait,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::wildcard_in_or_patterns,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+    clippy::unnested_or_patterns,
+)]
+// Ignored clippy_pedantic lints
+#![allow(
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::items_after_statements,
+    clippy::let_underscore_drop,
+    clippy::manual_assert,
+    clippy::match_same_arms,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
+    clippy::match_wildcard_for_single_variants,
+    clippy::missing_errors_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::struct_excessive_bools,
+    clippy::too_many_lines,
+    clippy::unused_self,
+    clippy::wildcard_imports
 )]
 
 #[macro_use]
@@ -16,7 +43,8 @@ extern crate syn;
 extern crate proc_macro2;
 extern crate quote;
 
-#[path = "src/mod.rs"]
+#[cfg_attr(serde_build_from_git, path = "../serde_derive/src/internals/mod.rs")]
+#[cfg_attr(not(serde_build_from_git), path = "src/mod.rs")]
 mod internals;
 
 pub use internals::*;

serde_test/.clippy.toml

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

serde_test/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "serde_test"
-version = "1.0.99" # remember to update html_root_url
+version = "1.0.140" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+rust-version = "1.13"
 license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
 homepage = "https://serde.rs"
@@ -9,7 +10,8 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_test/"
 keywords = ["serde", "serialization"]
 readme = "crates-io.md"
-include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+build = "build.rs"
 
 [dependencies]
 serde = { version = "1.0.60", path = "../serde" }
@@ -18,6 +20,5 @@ serde = { version = "1.0.60", path = "../serde" }
 serde = { version = "1.0", path = "../serde" }
 serde_derive = { version = "1.0", path = "../serde_derive" }
 
-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

serde_test/build.rs

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

serde_test/src/assert.rs

@@ -12,7 +12,6 @@ use std::fmt::Debug;
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_tokens, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// struct S {
 ///     a: u8,
@@ -28,8 +27,8 @@ use std::fmt::Debug;
 ///     Token::U8(0),
 ///     Token::StructEnd,
 /// ]);
-/// # }
 /// ```
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Serialize + Deserialize<'de> + PartialEq + Debug,
@@ -44,7 +43,6 @@ where
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_ser_tokens, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// struct S {
 ///     a: u8,
@@ -60,9 +58,9 @@ where
 ///     Token::U8(0),
 ///     Token::StructEnd,
 /// ]);
-/// # }
 /// ```
-pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
+#[cfg_attr(track_caller, track_caller)]
+pub fn assert_ser_tokens<T: ?Sized>(value: &T, tokens: &[Token])
 where
     T: Serialize,
 {
@@ -114,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(track_caller, track_caller)]
+pub fn assert_ser_tokens_error<T: ?Sized>(value: &T, tokens: &[Token], error: &str)
 where
     T: Serialize,
 {
@@ -135,7 +134,6 @@ where
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// struct S {
 ///     a: u8,
@@ -151,8 +149,8 @@ where
 ///     Token::U8(0),
 ///     Token::StructEnd,
 /// ]);
-/// # }
 /// ```
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Deserialize<'de> + PartialEq + Debug,
@@ -190,7 +188,6 @@ where
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens_error, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// #[serde(deny_unknown_fields)]
 /// struct S {
@@ -205,8 +202,8 @@ where
 ///     ],
 ///     "unknown field `x`, expected `a` or `b`",
 /// );
-/// # }
 /// ```
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_de_tokens_error<'de, T>(tokens: &'de [Token], error: &str)
 where
     T: Deserialize<'de>,

serde_test/src/configure.rs

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

serde_test/src/de.rs

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

serde_test/src/lib.rs

@@ -144,19 +144,25 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.99")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.140")]
 #![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))]
+#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
 // Ignored clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
+        cloned_instead_of_copied,
+        doc_link_with_quotes, // https://github.com/rust-lang/rust-clippy/issues/8961
         empty_line_after_outer_attr,
+        manual_assert,
         missing_docs_in_private_items,
+        missing_panics_doc,
         module_name_repetitions,
+        must_use_candidate,
         redundant_field_names,
+        too_many_lines,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
         use_debug,
         use_self
     )

serde_test/src/ser.rs

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

test_suite/Cargo.toml

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

test_suite/build.rs

@@ -0,0 +1,25 @@
+use std::process::{Command, ExitStatus, Stdio};
+
+fn has_cargo_expand() -> bool {
+    let cargo_expand = if cfg!(windows) {
+        "cargo-expand.exe"
+    } else {
+        "cargo-expand"
+    };
+
+    Command::new(cargo_expand)
+        .arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .as_ref()
+        .map(ExitStatus::success)
+        .unwrap_or(false)
+}
+
+fn main() {
+    if cfg!(feature = "expandtest") && has_cargo_expand() {
+        println!("cargo:rustc-cfg=expandtest");
+    }
+}

test_suite/tests/compiletest.rs

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

test_suite/tests/expand/de_enum.rs

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

test_suite/tests/expand/default_ty_param.expanded.rs

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

test_suite/tests/expand/default_ty_param.rs

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

test_suite/tests/expand/generic_enum.expanded.rs

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

test_suite/tests/expand/generic_enum.rs

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

test_suite/tests/expand/generic_struct.expanded.rs

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

test_suite/tests/expand/generic_struct.rs

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

test_suite/tests/expand/generic_tuple_struct.expanded.rs

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

test_suite/tests/expand/generic_tuple_struct.rs

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

test_suite/tests/expand/lifetimes.expanded.rs

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

test_suite/tests/expand/lifetimes.rs

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

test_suite/tests/expand/named_map.expanded.rs

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

test_suite/tests/expand/named_map.rs

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

test_suite/tests/expand/named_tuple.expanded.rs

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

test_suite/tests/expand/named_tuple.rs

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

test_suite/tests/expand/named_unit.expanded.rs

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

test_suite/tests/expand/named_unit.rs

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

test_suite/tests/expand/ser_enum.expanded.rs

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

test_suite/tests/expand/ser_enum.rs

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

test_suite/tests/expand/void.expanded.rs

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

test_suite/tests/expand/void.rs

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

test_suite/tests/expandtest.rs

@@ -0,0 +1,9 @@
+#[cfg_attr(target_os = "emscripten", ignore)]
+#[cfg_attr(not(expandtest), ignore)]
+#[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
+#[allow(unused_attributes)]
+#[test]
+fn expandtest() {
+    macrotest::expand("tests/expand/*.rs");
+}

test_suite/tests/macros/mod.rs

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

test_suite/tests/test_annotations.rs

@@ -1,4 +1,13 @@
-#![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
+)]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -1967,6 +1976,29 @@ fn test_flatten_map_twice() {
     );
 }
 
+#[test]
+fn test_flatten_unit() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Response<T> {
+        #[serde(flatten)]
+        data: T,
+        status: usize,
+    }
+
+    assert_tokens(
+        &Response {
+            data: (),
+            status: 0,
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("status"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_flatten_unsupported_type() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -2610,3 +2642,171 @@ fn test_flatten_any_after_flatten_struct() {
         ],
     );
 }
+
+#[test]
+fn test_expecting_message() {
+    #[derive(Deserialize, PartialEq, Debug)]
+    #[serde(expecting = "something strange...")]
+    struct Unit;
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Newtype(bool);
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Tuple(u32, bool);
+
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    struct Struct {
+        question: String,
+        answer: u32,
+    }
+
+    assert_de_tokens_error::<Unit>(
+        &[Token::Str("Unit")],
+        r#"invalid type: string "Unit", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Newtype>(
+        &[Token::Str("Newtype")],
+        r#"invalid type: string "Newtype", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Tuple>(
+        &[Token::Str("Tuple")],
+        r#"invalid type: string "Tuple", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Struct>(
+        &[Token::Str("Struct")],
+        r#"invalid type: string "Struct", expected something strange..."#,
+    );
+}
+
+#[test]
+fn test_expecting_message_externally_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        ExternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("ExternallyTagged")],
+        r#"invalid type: string "ExternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Enum { name: "Enum" }, Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_internally_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        InternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("InternallyTagged")],
+        r#"invalid type: string "InternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_adjacently_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag", content = "content")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        AdjacentlyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("AdjacentlyTagged")],
+        r#"invalid type: string "AdjacentlyTagged", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Unit],
+        r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        r#"invalid type: unit value, expected variant identifier"#,
+    );
+}
+
+#[test]
+fn test_expecting_message_untagged_tagged_enum() {
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        Untagged,
+    }
+
+    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], r#"something strange..."#);
+}
+
+#[test]
+fn test_expecting_message_identifier_enum() {
+    #[derive(Deserialize)]
+    #[serde(field_identifier)]
+    #[serde(expecting = "something strange...")]
+    enum FieldEnum {
+        Field,
+    }
+
+    #[derive(Deserialize)]
+    #[serde(variant_identifier)]
+    #[serde(expecting = "something strange...")]
+    enum VariantEnum {
+        Variant,
+    }
+
+    assert_de_tokens_error::<FieldEnum>(
+        &[Token::Unit],
+        r#"invalid type: unit value, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<FieldEnum>(
+        &[
+            Token::Enum { name: "FieldEnum" },
+            Token::Str("Unknown"),
+            Token::None,
+        ],
+        r#"invalid type: map, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<VariantEnum>(
+        &[Token::Unit],
+        r#"invalid type: unit value, expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<VariantEnum>(
+        &[
+            Token::Enum {
+                name: "VariantEnum",
+            },
+            Token::Str("Unknown"),
+            Token::None,
+        ],
+        r#"invalid type: map, expected something strange..."#,
+    );
+}

test_suite/tests/test_borrow.rs

@@ -1,3 +1,9 @@
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::items_after_statements,
+    clippy::used_underscore_binding
+)]
+
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
 
@@ -90,6 +96,30 @@ fn test_struct() {
     );
 }
 
+#[test]
+fn test_field_identifier() {
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldStr<'a> {
+        #[serde(borrow)]
+        Str(&'a str),
+    }
+
+    assert_de_tokens(&FieldStr::Str("value"), &[Token::BorrowedStr("value")]);
+
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldBytes<'a> {
+        #[serde(borrow)]
+        Bytes(&'a [u8]),
+    }
+
+    assert_de_tokens(
+        &FieldBytes::Bytes(b"value"),
+        &[Token::BorrowedBytes(b"value")],
+    );
+}
+
 #[test]
 fn test_cow() {
     #[derive(Deserialize)]

test_suite/tests/test_gen.rs

@@ -3,8 +3,21 @@
 // types involved.
 
 #![deny(warnings)]
-#![cfg_attr(feature = "unstable", feature(non_ascii_idents))]
-#![allow(clippy::trivially_copy_pass_by_ref)]
+#![allow(
+    unknown_lints,
+    mixed_script_confusables,
+    clippy::derive_partial_eq_without_eq,
+    clippy::items_after_statements,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::must_use_candidate,
+    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
+    clippy::nonstandard_macro_braces,
+    clippy::ptr_arg,
+    clippy::too_many_lines,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
+)]
 
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -262,10 +275,9 @@ fn test_gen() {
     }
     assert::<EmptyEnumVariant>();
 
-    #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     struct NonAsciiIdents {
-        σ:  f64,
+        σ: f64,
     }
 
     #[derive(Serialize, Deserialize)]
@@ -638,7 +650,7 @@ fn test_gen() {
     assert::<SkippedVariant<X>>();
 
     #[derive(Deserialize)]
-    struct ImpliciltyBorrowedOption<'a> {
+    struct ImplicitlyBorrowedOption<'a> {
         option: std::option::Option<&'a str>,
     }
 
@@ -691,6 +703,52 @@ fn test_gen() {
         #[serde(flatten, skip_deserializing)]
         flat: T,
     }
+
+    // https://github.com/serde-rs/serde/issues/1804
+    #[derive(Serialize, Deserialize)]
+    enum Message {
+        #[serde(skip)]
+        #[allow(dead_code)]
+        String(String),
+        #[serde(other)]
+        Unknown,
+    }
+
+    #[derive(Serialize)]
+    #[repr(packed)]
+    struct Packed {
+        x: u8,
+        y: u16,
+    }
+
+    macro_rules! deriving {
+        ($field:ty) => {
+            #[derive(Deserialize)]
+            struct MacroRules<'a> {
+                field: $field,
+            }
+        };
+    }
+
+    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>,
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -764,3 +822,72 @@ where
 pub fn is_zero(n: &u8) -> bool {
     *n == 0
 }
+
+fn vec_first_element<T, S>(vec: &Vec<T>, serializer: S) -> StdResult<S::Ok, S::Error>
+where
+    T: Serialize,
+    S: Serializer,
+{
+    vec.first().serialize(serializer)
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug, PartialEq, Deserialize)]
+#[serde(tag = "tag")]
+enum InternallyTagged {
+    #[serde(deserialize_with = "deserialize_generic")]
+    Unit,
+
+    #[serde(deserialize_with = "deserialize_generic")]
+    Newtype(i32),
+
+    #[serde(deserialize_with = "deserialize_generic")]
+    Struct { f1: String, f2: u8 },
+}
+
+fn deserialize_generic<'de, T, D>(deserializer: D) -> StdResult<T, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    T::deserialize(deserializer)
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#[repr(packed)]
+pub struct RemotePacked {
+    pub a: u16,
+    pub b: u32,
+}
+
+#[derive(Serialize)]
+#[repr(packed)]
+#[serde(remote = "RemotePacked")]
+pub struct RemotePackedDef {
+    a: u16,
+    b: u32,
+}
+
+impl Drop for RemotePackedDef {
+    fn drop(&mut self) {}
+}
+
+#[repr(packed)]
+pub struct RemotePackedNonCopy {
+    pub a: u16,
+    pub b: String,
+}
+
+#[derive(Deserialize)]
+#[repr(packed)]
+#[serde(remote = "RemotePackedNonCopy")]
+pub struct RemotePackedNonCopyDef {
+    a: u16,
+    b: String,
+}
+
+impl Drop for RemotePackedNonCopyDef {
+    fn drop(&mut self) {}
+}

test_suite/tests/test_identifier.rs

@@ -1,3 +1,7 @@
+//! Tests for `#[serde(field_identifier)]` and `#[serde(variant_identifier)]`
+
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 use serde::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 
@@ -27,6 +31,10 @@ fn test_field_identifier() {
         Bbb,
     }
 
+    assert_de_tokens(&F::Aaa, &[Token::U8(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U16(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U32(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U64(0)]);
     assert_de_tokens(&F::Aaa, &[Token::Str("aaa")]);
     assert_de_tokens(&F::Aaa, &[Token::Bytes(b"aaa")]);
 }
@@ -42,6 +50,10 @@ fn test_unit_fallthrough() {
         Other,
     }
 
+    assert_de_tokens(&F::Other, &[Token::U8(42)]);
+    assert_de_tokens(&F::Other, &[Token::U16(42)]);
+    assert_de_tokens(&F::Other, &[Token::U32(42)]);
+    assert_de_tokens(&F::Other, &[Token::U64(42)]);
     assert_de_tokens(&F::Other, &[Token::Str("x")]);
 }
 
@@ -68,5 +80,9 @@ fn test_newtype_fallthrough_generic() {
         Other(T),
     }
 
+    assert_de_tokens(&F::Other(42u8), &[Token::U8(42)]);
+    assert_de_tokens(&F::Other(42u16), &[Token::U16(42)]);
+    assert_de_tokens(&F::Other(42u32), &[Token::U32(42)]);
+    assert_de_tokens(&F::Other(42u64), &[Token::U64(42)]);
     assert_de_tokens(&F::Other("x".to_owned()), &[Token::Str("x")]);
 }

test_suite/tests/test_ignored_any.rs

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