Run test suite on wa-serde-derive

Compile serde_derive to wasm
2026-04-23 22:17:59 +00:00 · 2022-07-01 17:56:18 -07:00 · 2022-07-01 17:55:51 -07:00
80 changed files with 6055 additions and 854 deletions
@@ -5,9 +5,6 @@ on:
  pull_request:
  schedule: [cron: "40 1 * * *"]

-permissions:
-  contents: read
-
 env:
  RUSTFLAGS: -Dwarnings

@@ -15,16 +12,18 @@ jobs:
  test:
    name: Test suite
    runs-on: ubuntu-latest
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@nightly
      - run: cd test_suite && cargo test --features unstable
+      - uses: dtolnay/install@cargo-expand
+        if: github.event_name != 'pull_request'
+      - run: cd test_suite && cargo test --features expandtest --test expandtest -- --include-ignored
+        if: github.event_name != 'pull_request'

  windows:
    name: Test suite (windows)
    runs-on: windows-latest
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@nightly
@@ -37,7 +36,6 @@ jobs:
      fail-fast: false
      matrix:
        rust: [stable, beta]
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@master
@@ -55,7 +53,6 @@ jobs:
      fail-fast: false
      matrix:
        os: [ubuntu, windows]
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@nightly
@@ -71,6 +68,23 @@ jobs:
          RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
        if: matrix.os != 'windows'

+  msrv:
+    name: Rust 1.13.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@1.13.0
+      - name: Get timestamp for cache
+        id: date
+        run: echo ::set-output name=yearmo::$(date +%Y%m)
+      - uses: actions/cache@v1
+        with:
+          path: ~/.cargo/registry/index
+          key: cargo-registry-index-${{steps.date.outputs.yearmo}}
+      - run: cd serde && cargo build --features rc
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde_test && cargo build
+
  build:
    name: Rust ${{matrix.rust}}
    runs-on: ubuntu-latest
@@ -78,16 +92,13 @@ jobs:
      fail-fast: false
      matrix:
        rust: [1.19.0, 1.20.0, 1.21.0, 1.25.0, 1.26.0, 1.34.0]
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{matrix.rust}}
-      - run: cd serde && cargo build --features rc
      - run: cd serde && cargo build --no-default-features
      - run: cd serde && cargo build
-      - run: cd serde_test && cargo build

  more:
    name: Rust ${{matrix.rust}}
@@ -96,7 +107,6 @@ jobs:
      fail-fast: false
      matrix:
        rust: [1.27.0, 1.28.0]
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@master
@@ -110,7 +120,6 @@ jobs:
  derive:
    name: Rust 1.31.0
    runs-on: ubuntu-latest
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@1.31.0
@@ -121,17 +130,37 @@ jobs:
  alloc:
    name: Rust 1.36.0
    runs-on: ubuntu-latest
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@1.36.0
      - run: cd serde && cargo build --no-default-features --features alloc

+  emscripten:
+    name: Emscripten
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 9
+      - name: Install cargo-web
+        run: |
+          CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
+          CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
+          CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
+          mkdir -p ~/.cargo/bin
+          curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
+          chmod +x ~/.cargo/bin/cargo-web
+      - run: cd test_suite && cargo web test --target=asmjs-unknown-emscripten --nodejs
+        continue-on-error: true
+      - run: cd test_suite && cargo web test --target=wasm32-unknown-emscripten --nodejs
+        continue-on-error: true
+
  clippy:
    name: Clippy
    runs-on: ubuntu-latest
    if: github.event_name != 'pull_request'
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@clippy
@@ -145,7 +174,6 @@ jobs:
  miri:
    name: Miri
    runs-on: ubuntu-latest
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@miri
@@ -160,8 +188,7 @@ jobs:
    name: Outdated
    runs-on: ubuntu-latest
    if: github.event_name != 'pull_request'
-    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/install@cargo-outdated
-      - run: cargo outdated --workspace --exit-code 1
+      - run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1
@@ -1,7 +1,6 @@
 [workspace]
 members = [
    "serde",
-    "serde_derive",
    "serde_derive_internals",
    "serde_test",
    "test_suite",
@@ -174,3 +174,28 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   of your accepting any such warranty or additional liability.

 END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
@@ -1,12 +1,12 @@
-# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![serde_derive: rustc 1.31+]][Rust 1.31]
+# Serde &emsp; [![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://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master
+[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
-[serde: rustc 1.19+]: https://img.shields.io/badge/serde-rustc_1.19+-lightgray.svg
+[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.19]: https://blog.rust-lang.org/2017/07/20/Rust-1.19.html
+[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.**
@@ -19,7 +19,7 @@ You may be looking for:
 - [Data formats supported by Serde](https://serde.rs/#data-formats)
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
 - [Examples](https://serde.rs/examples.html)
- [API documentation](https://docs.rs/serde)
+- [API documentation](https://docs.serde.rs/serde/)
 - [Release notes](https://github.com/serde-rs/serde/releases)

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

 ## Serde in action
@@ -1,28 +1,25 @@
 [package]
 name = "serde"
-version = "1.0.153" # remember to update html_root_url and serde_derive dependency
+version = "1.0.137" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-build = "build.rs"
-categories = ["encoding", "no-std"]
-description = "A generic serialization/deserialization framework"
-documentation = "https://docs.rs/serde"
-homepage = "https://serde.rs"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-keywords = ["serde", "serialization", "no_std"]
+rust-version = "1.13"
 license = "MIT OR Apache-2.0"
-readme = "crates-io.md"
+description = "A generic serialization/deserialization framework"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-rust-version = "1.19"
+documentation = "https://docs.serde.rs/serde/"
+keywords = ["serde", "serialization", "no_std"]
+categories = ["encoding"]
+readme = "crates-io.md"
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+build = "build.rs"

 [dependencies]
-serde_derive = { version = "=1.0.153", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.137", optional = true, path = "../serde_derive" }

 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

-[lib]
-doc-scrape-examples = false
-
 [package.metadata.playground]
 features = ["derive", "rc"]

@@ -6,8 +6,6 @@ use std::str::{self, FromStr};
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
    let minor = match rustc_minor_version() {
        Some(minor) => minor,
        None => return,
@@ -91,28 +89,24 @@ fn main() {
        println!("cargo:rustc-cfg=no_core_try_from");
        println!("cargo:rustc-cfg=no_num_nonzero_signed");
        println!("cargo:rustc-cfg=no_systemtime_checked_add");
-        println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
    }

-    // Support for #[cfg(target_has_atomic = "...")] stabilized in Rust 1.60.
-    if minor < 60 {
-        println!("cargo:rustc-cfg=no_target_has_atomic");
-        // Allowlist of archs that support std::sync::atomic module. This is
-        // based on rustc's compiler/rustc_target/src/spec/*.rs.
-        let has_atomic64 = target.starts_with("x86_64")
-            || target.starts_with("i686")
-            || target.starts_with("aarch64")
-            || target.starts_with("powerpc64")
-            || target.starts_with("sparc64")
-            || target.starts_with("mips64el")
-            || target.starts_with("riscv64");
-        let has_atomic32 = has_atomic64 || emscripten;
-        if minor < 34 || !has_atomic64 {
-            println!("cargo:rustc-cfg=no_std_atomic64");
-        }
-        if minor < 34 || !has_atomic32 {
-            println!("cargo:rustc-cfg=no_std_atomic");
-        }
+    // 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");
    }
 }

@@ -1,7 +1,7 @@
 use lib::fmt::{self, Write};
 use lib::str;

-pub(super) struct Buf<'a> {
+pub struct Buf<'a> {
    bytes: &'a mut [u8],
    offset: usize,
 }
@@ -228,7 +228,7 @@ impl<'de> Visitor<'de> for IgnoredAny {
    where
        A: EnumAccess<'de>,
    {
-        try!(data.variant::<IgnoredAny>()).1.newtype_variant()
+        data.variant::<IgnoredAny>()?.1.newtype_variant()
    }
 }

@@ -733,7 +733,7 @@ impl<'de> Deserialize<'de> for CString {
 macro_rules! forwarded_impl {
    (
        $(#[doc = $doc:tt])*
-        ($($id:ident),*), $ty:ty, $func:expr
+        ( $($id: ident),* ), $ty: ty, $func: expr
    ) => {
        $(#[doc = $doc])*
        impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
@@ -860,7 +860,7 @@ impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
 #[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! seq_impl {
    (
-        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
+        $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
        $access:ident,
        $clear:expr,
        $with_capacity:expr,
@@ -1353,7 +1353,7 @@ tuple_impls! {
 #[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! map_impl {
    (
-        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
+        $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
        $access:ident,
        $with_capacity:expr
    ) => {
@@ -1440,15 +1440,15 @@ macro_rules! parse_ip_impl {
 #[cfg(feature = "std")]
 macro_rules! variant_identifier {
    (
-        $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*)
-        $expecting_message:expr,
-        $variants_name:ident
+        $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
+        $expecting_message: expr,
+        $variants_name: ident
    ) => {
        enum $name_kind {
-            $($variant),*
+            $( $variant ),*
        }

-        static $variants_name: &'static [&'static str] = &[$(stringify!($variant)),*];
+        static $variants_name: &'static [&'static str] = &[ $( stringify!($variant) ),*];

        impl<'de> Deserialize<'de> for $name_kind {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1515,12 +1515,12 @@ macro_rules! variant_identifier {
 #[cfg(feature = "std")]
 macro_rules! deserialize_enum {
    (
-        $name:ident $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*)
-        $expecting_message:expr,
-        $deserializer:expr
+        $name: ident $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
+        $expecting_message: expr,
+        $deserializer: expr
    ) => {
-        variant_identifier! {
-            $name_kind ($($variant; $bytes; $index),*)
+        variant_identifier!{
+            $name_kind ( $($variant; $bytes; $index),* )
            $expecting_message,
            VARIANTS
        }
@@ -2268,14 +2268,14 @@ where
    where
        D: Deserializer<'de>,
    {
-        let (start, end) = try!(deserializer.deserialize_struct(
+        let (start, end) = deserializer.deserialize_struct(
            "Range",
            range::FIELDS,
            range::RangeVisitor {
                expecting: "struct Range",
                phantom: PhantomData,
            },
-        ));
+        )?;
        Ok(start..end)
    }
 }
@@ -2289,14 +2289,14 @@ where
    where
        D: Deserializer<'de>,
    {
-        let (start, end) = try!(deserializer.deserialize_struct(
+        let (start, end) = deserializer.deserialize_struct(
            "RangeInclusive",
            range::FIELDS,
            range::RangeVisitor {
                expecting: "struct RangeInclusive",
                phantom: PhantomData,
            },
-        ));
+        )?;
        Ok(RangeInclusive::new(start, end))
    }
 }
@@ -2662,9 +2662,8 @@ where

 #[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
-    ($($ty:ident $size:expr)*) => {
+    ($($ty:ident)*) => {
        $(
-            #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
            impl<'de> Deserialize<'de> for $ty {
                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                where
@@ -2679,21 +2678,14 @@ macro_rules! atomic_impl {

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

 #[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
-    AtomicI64 "64"
-    AtomicU64 "64"
+    AtomicI64 AtomicU64
 }

 #[cfg(feature = "std")]
@@ -30,7 +30,7 @@
 //! # The Deserializer trait
 //!
 //! [`Deserializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
+//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
 //!
 //! A partial list of well-maintained formats is given on the [Serde
 //! website][data formats].
@@ -104,7 +104,7 @@
 //! [`Deserialize`]: ../trait.Deserialize.html
 //! [`Deserializer`]: ../trait.Deserializer.html
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`postcard`]: https://github.com/jamesmunns/postcard
+//! [`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
@@ -501,8 +501,8 @@ impl<'a> Display for Expected + 'a {
 /// by Serde.
 ///
 /// Serde provides `Deserialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][crate::de]. All of these
-/// can be deserialized using Serde out of the box.
+/// standard library types. The complete list is [here][de]. All of these can
+/// be deserialized using Serde out of the box.
 ///
 /// Additionally, Serde provides a procedural macro called `serde_derive` to
 /// automatically generate `Deserialize` implementations for structs and enums
@@ -518,6 +518,7 @@ impl<'a> Display for Expected + 'a {
 /// `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate
 /// provides an implementation of `Deserialize` for it.
 ///
+/// [de]: https://docs.serde.rs/serde/de/index.html
 /// [derive]: https://serde.rs/derive.html
 /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
 ///
@@ -564,7 +565,7 @@ pub trait Deserialize<'de>: Sized {
        D: Deserializer<'de>,
    {
        // Default implementation just delegates to `deserialize` impl.
-        *place = try!(Deserialize::deserialize(deserializer));
+        *place = Deserialize::deserialize(deserializer)?;
        Ok(())
    }
 }
@@ -707,11 +708,6 @@ 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()? {
@@ -861,10 +857,10 @@ where
 /// The `Deserializer` trait supports two entry point styles which enables
 /// different kinds of deserialization.
 ///
-/// 1. The `deserialize_any` method. Self-describing data formats like JSON are
-///    able to look at the serialized data and tell what it represents. For
-///    example the JSON deserializer may see an opening curly brace (`{`) and
-///    know that it is seeing a map. If the data format supports
+/// 1. The `deserialize` method. Self-describing data formats like JSON are able
+///    to look at the serialized data and tell what it represents. For example
+///    the JSON deserializer may see an opening curly brace (`{`) and know that
+///    it is seeing a map. If the data format supports
 ///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever
 ///    type it sees in the input. JSON uses this approach when deserializing
 ///    `serde_json::Value` which is an enum that can represent any JSON
@@ -873,7 +869,7 @@ where
 ///    `Deserializer::deserialize_any`.
 ///
 /// 2. The various `deserialize_*` methods. Non-self-describing formats like
-///    Postcard need to be told what is in the input in order to deserialize it.
+///    Bincode need to be told what is in the input in order to deserialize it.
 ///    The `deserialize_*` methods are hints to the deserializer for how to
 ///    interpret the next piece of input. Non-self-describing formats are not
 ///    able to deserialize something like `serde_json::Value` which relies on
@@ -883,7 +879,7 @@ where
 /// `Deserializer::deserialize_any` unless you need to be told by the
 /// Deserializer what type is in the input. Know that relying on
 /// `Deserializer::deserialize_any` means your data type will be able to
-/// deserialize from self-describing formats only, ruling out Postcard and many
+/// deserialize from self-describing formats only, ruling out Bincode and many
 /// others.
 ///
 /// [Serde data model]: https://serde.rs/data-model.html
@@ -914,7 +910,7 @@ pub trait Deserializer<'de>: Sized {
    /// `Deserializer::deserialize_any` unless you need to be told by the
    /// Deserializer what type is in the input. Know that relying on
    /// `Deserializer::deserialize_any` means your data type will be able to
-    /// deserialize from self-describing formats only, ruling out Postcard and
+    /// deserialize from self-describing formats only, ruling out Bincode and
    /// many others.
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
@@ -1155,7 +1151,7 @@ pub trait Deserializer<'de>: Sized {
    /// Some types have a human-readable form that may be somewhat expensive to
    /// construct, as well as a binary form that is compact and efficient.
    /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Postcard will prefer the
+    /// human-readable one and binary formats like Bincode will prefer the
    /// compact one.
    ///
    /// ```edition2018
@@ -1559,7 +1555,7 @@ pub trait Visitor<'de>: Sized {
    /// `Deserializer`.
    ///
    /// This enables zero-copy deserialization of bytes in some formats. For
-    /// example Postcard data containing bytes can be deserialized with zero
+    /// example Bincode data containing bytes can be deserialized with zero
    /// copying into a `&'a [u8]` as long as the input data outlives `'a`.
    ///
    /// The default implementation forwards to `visit_bytes`.
@@ -128,7 +128,9 @@ where
    type Deserializer = UnitDeserializer<E>;

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

@@ -139,15 +141,6 @@ pub struct UnitDeserializer<E> {

 impl_copy_clone!(UnitDeserializer);

-impl<E> UnitDeserializer<E> {
-    #[allow(missing_docs)]
-    pub fn new() -> Self {
-        UnitDeserializer {
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
 where
    E: de::Error,
@@ -243,15 +236,8 @@ 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: value,
+                    value: self,
                    marker: PhantomData,
                }
            }
@@ -322,15 +308,8 @@ 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: value,
+            value: self,
            marker: PhantomData,
        }
    }
@@ -411,15 +390,8 @@ 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: value,
+            value: self,
            marker: PhantomData,
        }
    }
@@ -589,16 +561,8 @@ 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: value,
+            value: self,
            marker: PhantomData,
        }
    }
@@ -692,16 +656,8 @@ 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: value,
+            value: self,
            marker: PhantomData,
        }
    }
@@ -1501,7 +1457,7 @@ where
    where
        T: de::DeserializeSeed<'de>,
    {
-        match try!(self.map.next_key_seed(seed)) {
+        match self.map.next_key_seed(seed)? {
            Some(key) => Ok((key, private::map_as_enum(self.map))),
            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
        }
@@ -1510,41 +1466,6 @@ where

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

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

@@ -31,7 +31,8 @@
 //! for Serde by the community.
 //!
 //! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.
-//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
+//! - [Bincode], a compact binary format
+//!   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 self-proclaimed human-friendly configuration language that ain't
@@ -44,9 +45,8 @@
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
 //! - [JSON5], a superset of JSON including some productions from ES5.
+//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
 //! - [URL] query strings, in the x-www-form-urlencoded format.
-//! - [Starlark], the format used for describing build targets by the Bazel and
-//!   Buck build systems. *(serialization only)*
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(deserialization only)*
 //! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
@@ -54,29 +54,23 @@
 //! - [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.
-//! - [Bencode], a simple binary format used in the BitTorrent protocol.
-//! - [Token streams], for processing Rust procedural macro input.
-//!   *(deserialization only)*
+//! - [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.
-//! - [Hjson], a syntax extension to JSON designed around human reading and
-//!   editing. *(deserialization only)*
 //!
 //! [JSON]: https://github.com/serde-rs/json
-//! [Postcard]: https://github.com/jamesmunns/postcard
+//! [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://docs.rs/toml
+//! [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/mongodb/bson-rust
-//! [Avro]: https://docs.rs/apache-avro
+//! [Avro]: https://github.com/flavray/avro-rs
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
+//! [Postcard]: https://github.com/jamesmunns/postcard
 //! [URL]: https://docs.rs/serde_qs
-//! [Starlark]: https://github.com/dtolnay/serde-starlark
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -84,23 +78,20 @@
 //! [S-expressions]: https://github.com/rotty/lexpr-rs
 //! [D-Bus]: https://docs.rs/zvariant
 //! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
-//! [Bencode]: https://github.com/P3KI/bendy
-//! [Token streams]: https://github.com/oxidecomputer/serde_tokenstream
 //! [DynamoDB Items]: https://docs.rs/serde_dynamo
 //! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
-//! [Hjson]: https://github.com/Canop/deser-hjson

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

 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.153")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.137")]
 // 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(error_in_core, 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))]
 // Ignored clippy and clippy_pedantic lints
@@ -129,10 +120,8 @@
        // correctly used
        derive_partial_eq_without_eq,
        enum_glob_use,
-        explicit_auto_deref,
-        let_underscore_untyped,
+        let_underscore_drop,
        map_err_ignore,
-        new_without_default,
        result_unit_err,
        wildcard_imports,
        // not practical
@@ -249,44 +238,18 @@ mod lib {
    #[cfg(not(no_range_inclusive))]
    pub use self::core::ops::RangeInclusive;

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

-    #[cfg(all(feature = "std", not(no_target_has_atomic)))]
-    pub use std::sync::atomic::Ordering;
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "8"))]
-    pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "16"))]
-    pub use std::sync::atomic::{AtomicI16, AtomicU16};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "32"))]
-    pub use std::sync::atomic::{AtomicI32, AtomicU32};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "64"))]
-    pub use std::sync::atomic::{AtomicI64, AtomicU64};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))]
-    pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
-
    #[cfg(any(feature = "std", not(no_core_duration)))]
    pub use self::core::time::Duration;
 }

-// None of this crate's error handling needs the `From::from` error conversion
-// performed implicitly by the `?` operator or the standard library's `try!`
-// macro. This simplified macro gives a 5.5% improvement in compile time
-// compared to standard `try!`, and 9% improvement compared to `?`.
-macro_rules! try {
-    ($expr:expr) => {
-        match $expr {
-            Ok(val) => val,
-            Err(err) => return Err(err),
-        }
-    };
-}
-
 ////////////////////////////////////////////////////////////////////////////////

 #[macro_use]
@@ -316,7 +279,7 @@ use self::__private as private;
 #[path = "de/seed.rs"]
 mod seed;

-#[cfg(not(any(feature = "std", feature = "unstable")))]
+#[cfg(not(feature = "std"))]
 mod std_error;

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

 #[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! forward_to_deserialize_other {
-    ($($func:ident ($($arg:ty),*))*) => {
+    ($($func:ident ( $($arg:ty),* ))*) => {
        $(
            fn $func<V>(self, $(_: $arg,)* _visitor: V) -> Result<V::Value, Self::Error>
            where
@@ -51,6 +51,7 @@ enum Unsupported {
    String,
    ByteArray,
    Optional,
+    Unit,
    #[cfg(any(feature = "std", feature = "alloc"))]
    UnitStruct,
    Sequence,
@@ -69,6 +70,7 @@ impl Display for Unsupported {
            Unsupported::String => formatter.write_str("a string"),
            Unsupported::ByteArray => formatter.write_str("a byte array"),
            Unsupported::Optional => formatter.write_str("an optional"),
+            Unsupported::Unit => formatter.write_str("unit"),
            #[cfg(any(feature = "std", feature = "alloc"))]
            Unsupported::UnitStruct => formatter.write_str("unit struct"),
            Unsupported::Sequence => formatter.write_str("a sequence"),
@@ -182,9 +184,7 @@ where
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        let mut map = try!(self.delegate.serialize_map(Some(1)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        map.end()
+        Err(self.bad_type(Unsupported::Unit))
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
@@ -525,7 +525,7 @@ mod content {
                Content::Map(ref entries) => {
                    use ser::SerializeMap;
                    let mut map = try!(serializer.serialize_map(Some(entries.len())));
-                    for (k, v) in entries {
+                    for &(ref k, ref v) in entries {
                        try!(map.serialize_entry(k, v));
                    }
                    map.end()
@@ -182,27 +182,9 @@ where
    }
 }

-#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! seq_impl {
-    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
-        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
-        where
-            T: Serialize,
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_seq(self)
-            }
-        }
-    }
-}
-
-#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
-macro_rules! seq_impl {
-    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
+    ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => {
        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
        where
            T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
@@ -365,28 +347,9 @@ tuple_impls! {

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

-#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! map_impl {
-    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
-        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
-        where
-            K: Serialize,
-            V: Serialize,
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_map(self)
-            }
-        }
-    }
-}
-
-#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
-macro_rules! map_impl {
-    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
+    ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => {
        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
        where
            K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
@@ -502,7 +465,7 @@ where
 ////////////////////////////////////////////////////////////////////////////////

 macro_rules! nonzero_integers {
-    ($($T:ident,)+) => {
+    ( $( $T: ident, )+ ) => {
        $(
            #[cfg(not(no_num_nonzero))]
            impl Serialize for num::$T {
@@ -559,7 +522,7 @@ where
    }
 }

-impl<T: ?Sized> Serialize for RefCell<T>
+impl<T> Serialize for RefCell<T>
 where
    T: Serialize,
 {
@@ -575,7 +538,7 @@ where
 }

 #[cfg(feature = "std")]
-impl<T: ?Sized> Serialize for Mutex<T>
+impl<T> Serialize for Mutex<T>
 where
    T: Serialize,
 {
@@ -591,7 +554,7 @@ where
 }

 #[cfg(feature = "std")]
-impl<T: ?Sized> Serialize for RwLock<T>
+impl<T> Serialize for RwLock<T>
 where
    T: Serialize,
 {
@@ -651,10 +614,9 @@ impl Serialize for SystemTime {
        S: Serializer,
    {
        use super::SerializeStruct;
-        let duration_since_epoch = match self.duration_since(UNIX_EPOCH) {
-            Ok(duration_since_epoch) => duration_since_epoch,
-            Err(_) => return Err(S::Error::custom("SystemTime must be later than UNIX_EPOCH")),
-        };
+        let duration_since_epoch = self
+            .duration_since(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()));
@@ -773,9 +735,8 @@ impl Serialize for net::Ipv4Addr {
                // Skip over delimiters that we initialized buf with
                written += format_u8(*oct, &mut buf[written + 1..]) + 1;
            }
-            // Safety: We've only written ASCII bytes to the buffer, so it is valid UTF-8
-            let buf = unsafe { str::from_utf8_unchecked(&buf[..written]) };
-            serializer.serialize_str(buf)
+            // 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)
        }
@@ -947,16 +908,15 @@ where

 #[cfg(all(feature = "std", not(no_std_atomic)))]
 macro_rules! atomic_impl {
-    ($($ty:ident $size:expr)*) => {
+    ($($ty:ident)*) => {
        $(
-            #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
            impl Serialize for $ty {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
                    S: Serializer,
                {
                    // Matches the atomic ordering used in libcore for the Debug impl
-                    self.load(Ordering::Relaxed).serialize(serializer)
+                    self.load(Ordering::SeqCst).serialize(serializer)
                }
            }
        )*
@@ -965,19 +925,12 @@ macro_rules! atomic_impl {

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

 #[cfg(all(feature = "std", not(no_std_atomic64)))]
 atomic_impl! {
-    AtomicI64 "64"
-    AtomicU64 "64"
+    AtomicI64 AtomicU64
 }
@@ -30,7 +30,7 @@
 //! # The Serializer trait
 //!
 //! [`Serializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
+//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
 //!
 //! A partial list of well-maintained formats is given on the [Serde
 //! website][data formats].
@@ -99,7 +99,7 @@
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
 //! [`Serialize`]: ../trait.Serialize.html
 //! [`Serializer`]: ../trait.Serializer.html
-//! [`postcard`]: https://github.com/jamesmunns/postcard
+//! [`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
@@ -115,13 +115,10 @@ mod impossible;

 pub use self::impossible::Impossible;

-#[cfg(all(feature = "unstable", not(feature = "std")))]
-#[doc(inline)]
-pub use core::error::Error as StdError;
 #[cfg(feature = "std")]
 #[doc(no_inline)]
 pub use std::error::Error as StdError;
-#[cfg(not(any(feature = "std", feature = "unstable")))]
+#[cfg(not(feature = "std"))]
 #[doc(no_inline)]
 pub use std_error::Error as StdError;

@@ -194,8 +191,8 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// by Serde.
 ///
 /// Serde provides `Serialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][crate::ser]. All of
-/// these can be serialized using Serde out of the box.
+/// standard library types. The complete list is [here][ser]. All of these can
+/// be serialized using Serde out of the box.
 ///
 /// Additionally, Serde provides a procedural macro called [`serde_derive`] to
 /// automatically generate `Serialize` implementations for structs and enums in
@@ -215,6 +212,7 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 /// [`serde_derive`]: https://crates.io/crates/serde_derive
 /// [derive section of the manual]: https://serde.rs/derive.html
+/// [ser]: https://docs.serde.rs/serde/ser/index.html
 pub trait Serialize {
    /// Serialize this value into the given Serde serializer.
    ///
@@ -316,7 +314,7 @@ pub trait Serialize {
 ///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
 ///
 /// Many Serde serializers produce text or binary data as output, for example
-/// JSON or Postcard. This is not a requirement of the `Serializer` trait, and
+/// JSON or Bincode. This is not a requirement of the `Serializer` trait, and
 /// there are serializers that do not produce text or binary output. One example
 /// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
 /// serializer) that produces a `serde_json::Value` data structure in memory as
@@ -1425,7 +1423,7 @@ pub trait Serializer: Sized {
    /// Some types have a human-readable form that may be somewhat expensive to
    /// construct, as well as a binary form that is compact and efficient.
    /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Postcard will prefer the
+    /// human-readable one and binary formats like Bincode will prefer the
    /// compact one.
    ///
    /// ```edition2018
@@ -1,33 +1,36 @@
 [package]
 name = "serde_derive"
-version = "1.0.153" # remember to update html_root_url
+version = "1.0.137" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-categories = ["no-std"]
-description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
-documentation = "https://serde.rs/derive.html"
-homepage = "https://serde.rs"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-keywords = ["serde", "serialization", "no_std", "derive"]
-license = "MIT OR Apache-2.0"
-readme = "crates-io.md"
-repository = "https://github.com/serde-rs/serde"
 rust-version = "1.31"
+license = "MIT OR Apache-2.0"
+description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
+homepage = "https://serde.rs"
+repository = "https://github.com/serde-rs/serde"
+documentation = "https://serde.rs/derive.html"
+keywords = ["serde", "serialization", "no_std"]
+readme = "crates-io.md"
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]

 [features]
 default = []
 deserialize_in_place = []

 [lib]
-name = "serde_derive"
-proc-macro = true
+crate-type = ["cdylib"]

 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = "1.0.104"
+syn = "1.0.90"

 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+
+[workspace]
+
+[patch.crates-io]
+proc-macro2 = { git = "https://github.com/dtolnay/watt" }
@@ -6,8 +6,6 @@ use std::str;
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
    let minor = match rustc_minor_version() {
        Some(minor) => minor,
        None => return,
@@ -15,14 +13,14 @@ fn main() {

    // Underscore const names stabilized in Rust 1.37:
    // https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html#using-unnamed-const-items-for-macros
-    if minor < 37 {
-        println!("cargo:rustc-cfg=no_underscore_consts");
+    if minor >= 37 {
+        println!("cargo:rustc-cfg=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");
+    if minor >= 51 {
+        println!("cargo:rustc-cfg=ptr_addr_of");
    }
 }

@@ -10,7 +10,6 @@ use fragment::{Expr, Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
 use pretend;
-use this;

 use std::collections::BTreeSet;
 use std::ptr;
@@ -112,13 +111,9 @@ struct Parameters {
    local: syn::Ident,

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

    /// Generics including any explicit and inferred bounds for the impl.
    generics: syn::Generics,
@@ -138,8 +133,10 @@ struct Parameters {
 impl Parameters {
    fn new(cont: &Container) -> Self {
        let local = cont.ident.clone();
-        let this_type = this::this_type(cont);
-        let this_value = this::this_value(cont);
+        let this = match cont.attrs.remote() {
+            Some(remote) => remote.clone(),
+            None => cont.ident.clone().into(),
+        };
        let borrowed = borrowed_lifetimes(cont);
        let generics = build_generics(cont, &borrowed);
        let has_getter = cont.data.has_getter();
@@ -147,8 +144,7 @@ impl Parameters {

        Parameters {
            local,
-            this_type,
-            this_value,
+            this,
            generics,
            borrowed,
            has_getter,
@@ -159,7 +155,7 @@ impl Parameters {
    /// Type name to use in error messages and `&'static str` arguments to
    /// various Deserializer methods.
    fn type_name(&self) -> String {
-        self.this_type.segments.last().unwrap().ident.to_string()
+        self.this.segments.last().unwrap().ident.to_string()
    }
 }

@@ -362,7 +358,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
        Data::Enum(_) => unreachable!(),
    };

-    let this_value = &params.this_value;
+    let this = &params.this;
    let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();

    let path = match transparent_field.attrs.deserialize_with() {
@@ -390,7 +386,7 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
    quote_block! {
        _serde::__private::Result::map(
            #path(__deserializer),
-            |__transparent| #this_value { #(#assign),* })
+            |__transparent| #this { #(#assign),* })
    }
 }

@@ -411,8 +407,7 @@ fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
 }

 fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
+    let this = &params.this;
    let type_name = cattrs.name().deserialize_name();

    let expecting = format!("unit struct {}", params.type_name());
@@ -422,7 +417,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
        struct __Visitor;

        impl<'de> _serde::de::Visitor<'de> for __Visitor {
-            type Value = #this_type;
+            type Value = #this;

            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -433,7 +428,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
            where
                __E: _serde::de::Error,
            {
-                _serde::__private::Ok(#this_value)
+                _serde::__private::Ok(#this)
            }
        }

@@ -448,8 +443,7 @@ fn deserialize_tuple(
    cattrs: &attr::Container,
    deserializer: Option<TokenStream>,
 ) -> Fragment {
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -463,7 +457,7 @@ fn deserialize_tuple(
        let local = &params.local;
        quote!(#local)
    } else {
-        quote!(#this_value)
+        quote!(#this)
    };

    let is_enum = variant_ident.is_some();
@@ -491,7 +485,7 @@ fn deserialize_tuple(

    let visitor_expr = quote! {
        __Visitor {
-            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData,
        }
    };
@@ -516,12 +510,12 @@ fn deserialize_tuple(

    quote_block! {
        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
+            type Value = #this #ty_generics;

            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -550,7 +544,7 @@ fn deserialize_tuple_in_place(
    cattrs: &attr::Container,
    deserializer: Option<TokenStream>,
 ) -> Fragment {
-    let this_type = &params.this_type;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -606,7 +600,7 @@ fn deserialize_tuple_in_place(

    quote_block! {
        struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this_type #ty_generics,
+            place: &#place_life mut #this #ty_generics,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

@@ -711,10 +705,9 @@ fn deserialize_seq(
    };

    if params.has_getter {
-        let this_type = &params.this_type;
-        let (_, ty_generics, _) = params.generics.split_for_impl();
+        let this = &params.this;
        result = quote! {
-            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
+            _serde::__private::Into::<#this>::into(#result)
        };
    }

@@ -808,14 +801,14 @@ fn deserialize_seq_in_place(
        }
    });

-    let this_type = &params.this_type;
+    let this = &params.this;
    let (_, ty_generics, _) = params.generics.split_for_impl();
    let let_default = match cattrs.default() {
        attr::Default::Default => Some(quote!(
-            let __default: #this_type #ty_generics = _serde::__private::Default::default();
+            let __default: #this #ty_generics  = _serde::__private::Default::default();
        )),
        attr::Default::Path(path) => Some(quote!(
-            let __default: #this_type #ty_generics = #path();
+            let __default: #this #ty_generics  = #path();
        )),
        attr::Default::None => {
            // We don't need the default value, to prevent an unused variable warning
@@ -856,10 +849,9 @@ fn deserialize_newtype_struct(

    let mut result = quote!(#type_path(__field0));
    if params.has_getter {
-        let this_type = &params.this_type;
-        let (_, ty_generics, _) = params.generics.split_for_impl();
+        let this = &params.this;
        result = quote! {
-            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
+            _serde::__private::Into::<#this>::into(#result)
        };
    }

@@ -909,8 +901,7 @@ fn deserialize_struct(
 ) -> Fragment {
    let is_enum = variant_ident.is_some();

-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -922,7 +913,7 @@ fn deserialize_struct(
        let local = &params.local;
        quote!(#local)
    } else {
-        quote!(#this_value)
+        quote!(#this)
    };

    let type_path = match variant_ident {
@@ -950,7 +941,7 @@ fn deserialize_struct(

    let visitor_expr = quote! {
        __Visitor {
-            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData,
        }
    };
@@ -1002,7 +993,7 @@ fn deserialize_struct(
    let visitor_seed = if is_enum && cattrs.has_flatten() {
        Some(quote! {
            impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
-                type Value = #this_type #ty_generics;
+                type Value = #this #ty_generics;

                fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
                where
@@ -1020,12 +1011,12 @@ fn deserialize_struct(
        #field_visitor

        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
+            type Value = #this #ty_generics;

            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1066,7 +1057,7 @@ fn deserialize_struct_in_place(
        return None;
    }

-    let this_type = &params.this_type;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -1132,7 +1123,7 @@ fn deserialize_struct_in_place(
        #field_visitor

        struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this_type #ty_generics,
+            place: &#place_life mut #this #ty_generics,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

@@ -1221,7 +1212,7 @@ fn deserialize_externally_tagged_enum(
    variants: &[Variant],
    cattrs: &attr::Container,
 ) -> Fragment {
-    let this_type = &params.this_type;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -1275,12 +1266,12 @@ fn deserialize_externally_tagged_enum(
        #variant_visitor

        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
+            type Value = #this #ty_generics;

            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1301,7 +1292,7 @@ fn deserialize_externally_tagged_enum(
            #type_name,
            VARIANTS,
            __Visitor {
-                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
+                marker: _serde::__private::PhantomData::<#this #ty_generics>,
                lifetime: _serde::__private::PhantomData,
            },
        )
@@ -1363,8 +1354,7 @@ fn deserialize_adjacently_tagged_enum(
    tag: &str,
    content: &str,
 ) -> Fragment {
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -1425,13 +1415,13 @@ fn deserialize_adjacently_tagged_enum(

            let arm = match variant.style {
                Style::Unit => quote! {
-                    _serde::__private::Ok(#this_value::#variant_ident)
+                    _serde::__private::Ok(#this::#variant_ident)
                },
                Style::Newtype if variant.attrs.deserialize_with().is_none() => {
                    let span = variant.original.span();
                    let func = quote_spanned!(span=> _serde::__private::de::missing_field);
                    quote! {
-                        #func(#content).map(#this_value::#variant_ident)
+                        #func(#content).map(#this::#variant_ident)
                    }
                }
                _ => {
@@ -1523,12 +1513,12 @@ fn deserialize_adjacently_tagged_enum(

        struct __Seed #de_impl_generics #where_clause {
            field: __Field,
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

        impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
+            type Value = #this #ty_generics;

            fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
            where
@@ -1541,12 +1531,12 @@ fn deserialize_adjacently_tagged_enum(
        }

        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
+            type Value = #this #ty_generics;

            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
                _serde::__private::Formatter::write_str(__formatter, #expecting)
@@ -1648,7 +1638,7 @@ fn deserialize_adjacently_tagged_enum(
            #type_name,
            FIELDS,
            __Visitor {
-                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
+                marker: _serde::__private::PhantomData::<#this #ty_generics>,
                lifetime: _serde::__private::PhantomData,
            },
        )
@@ -1717,10 +1707,10 @@ fn deserialize_externally_tagged_variant(

    match variant.style {
        Style::Unit => {
-            let this_value = &params.this_value;
+            let this = &params.this;
            quote_block! {
                try!(_serde::de::VariantAccess::unit_variant(__variant));
-                _serde::__private::Ok(#this_value::#variant_ident)
+                _serde::__private::Ok(#this::#variant_ident)
            }
        }
        Style::Newtype => deserialize_externally_tagged_newtype_variant(
@@ -1759,7 +1749,7 @@ fn deserialize_internally_tagged_variant(

    match effective_style(variant) {
        Style::Unit => {
-            let this_value = &params.this_value;
+            let this = &params.this;
            let type_name = params.type_name();
            let variant_name = variant.ident.to_string();
            let default = variant.fields.get(0).map(|field| {
@@ -1768,7 +1758,7 @@ fn deserialize_internally_tagged_variant(
            });
            quote_block! {
                try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
-                _serde::__private::Ok(#this_value::#variant_ident #default)
+                _serde::__private::Ok(#this::#variant_ident #default)
            }
        }
        Style::Newtype => deserialize_untagged_newtype_variant(
@@ -1806,7 +1796,7 @@ fn deserialize_untagged_variant(

    match effective_style(variant) {
        Style::Unit => {
-            let this_value = &params.this_value;
+            let this = &params.this;
            let type_name = params.type_name();
            let variant_name = variant.ident.to_string();
            let default = variant.fields.get(0).map(|field| {
@@ -1818,7 +1808,7 @@ fn deserialize_untagged_variant(
                    #deserializer,
                    _serde::__private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
                ) {
-                    _serde::__private::Ok(()) => _serde::__private::Ok(#this_value::#variant_ident #default),
+                    _serde::__private::Ok(()) => _serde::__private::Ok(#this::#variant_ident #default),
                    _serde::__private::Err(__err) => _serde::__private::Err(__err),
                }
            }
@@ -1853,13 +1843,14 @@ fn deserialize_externally_tagged_newtype_variant(
    field: &Field,
    cattrs: &attr::Container,
 ) -> Fragment {
-    let this_value = &params.this_value;
+    let this = &params.this;

    if field.attrs.skip_deserializing() {
+        let this = &params.this;
        let default = Expr(expr_is_missing(field, cattrs));
        return quote_block! {
            try!(_serde::de::VariantAccess::unit_variant(__variant));
-            _serde::__private::Ok(#this_value::#variant_ident(#default))
+            _serde::__private::Ok(#this::#variant_ident(#default))
        };
    }

@@ -1870,7 +1861,7 @@ fn deserialize_externally_tagged_newtype_variant(
            let func =
                quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
            quote_expr! {
-                _serde::__private::Result::map(#func(__variant), #this_value::#variant_ident)
+                _serde::__private::Result::map(#func(__variant), #this::#variant_ident)
            }
        }
        Some(path) => {
@@ -1879,7 +1870,7 @@ fn deserialize_externally_tagged_newtype_variant(
                #wrapper
                _serde::__private::Result::map(
                    _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
-                    |__wrapper| #this_value::#variant_ident(__wrapper.value))
+                    |__wrapper| #this::#variant_ident(__wrapper.value))
            }
        }
    }
@@ -1891,20 +1882,20 @@ fn deserialize_untagged_newtype_variant(
    field: &Field,
    deserializer: &TokenStream,
 ) -> Fragment {
-    let this_value = &params.this_value;
+    let this = &params.this;
    let field_ty = field.ty;
    match field.attrs.deserialize_with() {
        None => {
            let span = field.original.span();
            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
            quote_expr! {
-                _serde::__private::Result::map(#func(#deserializer), #this_value::#variant_ident)
+                _serde::__private::Result::map(#func(#deserializer), #this::#variant_ident)
            }
        }
        Some(path) => {
            quote_block! {
                let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
-                _serde::__private::Result::map(__value, #this_value::#variant_ident)
+                _serde::__private::Result::map(__value, #this::#variant_ident)
            }
        }
    }
@@ -1916,7 +1907,7 @@ fn deserialize_generated_identifier(
    is_variant: bool,
    other_idx: Option<usize>,
 ) -> Fragment {
-    let this_value = quote!(__Field);
+    let this = quote!(__Field);
    let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();

    let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
@@ -1936,7 +1927,7 @@ fn deserialize_generated_identifier(
    };

    let visitor_impl = Stmts(deserialize_identifier(
-        &this_value,
+        &this,
        fields,
        is_variant,
        fallthrough,
@@ -1991,8 +1982,8 @@ fn deserialize_custom_identifier(
        attr::Identifier::No => unreachable!(),
    };

-    let this_type = params.this_type.to_token_stream();
-    let this_value = params.this_value.to_token_stream();
+    let this = &params.this;
+    let this = quote!(#this);

    let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
        let last_ident = &last.ident;
@@ -2001,7 +1992,7 @@ fn deserialize_custom_identifier(
            // last variant (checked in `check_identifier`), so all preceding
            // are ordinary variants.
            let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::__private::Ok(#this_value::#last_ident));
+            let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident));
            (ordinary, Some(fallthrough), None)
        } else if let Style::Newtype = last.style {
            let ordinary = &variants[..variants.len() - 1];
@@ -2011,7 +2002,7 @@ fn deserialize_custom_identifier(
                        _serde::Deserialize::deserialize(
                            _serde::__private::de::IdentifierDeserializer::from(#value)
                        ),
-                        #this_value::#last_ident)
+                        #this::#last_ident)
                }
            };
            (
@@ -2059,7 +2050,7 @@ fn deserialize_custom_identifier(
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
    let visitor_impl = Stmts(deserialize_identifier(
-        &this_value,
+        &this,
        &names_idents,
        is_variant,
        fallthrough,
@@ -2072,18 +2063,18 @@ fn deserialize_custom_identifier(
        #names_const

        struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

        impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
+            type Value = #this #ty_generics;

            #visitor_impl
        }

        let __visitor = __FieldVisitor {
-            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
+            marker: _serde::__private::PhantomData::<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData,
        };
        _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
@@ -2091,7 +2082,7 @@ fn deserialize_custom_identifier(
 }

 fn deserialize_identifier(
-    this_value: &TokenStream,
+    this: &TokenStream,
    fields: &[(String, Ident, Vec<String>)],
    is_variant: bool,
    fallthrough: Option<TokenStream>,
@@ -2112,11 +2103,11 @@ fn deserialize_identifier(

    let constructors: &Vec<_> = &flat_fields
        .iter()
-        .map(|(_, ident)| quote!(#this_value::#ident))
+        .map(|(_, ident)| quote!(#this::#ident))
        .collect();
    let main_constructors: &Vec<_> = &fields
        .iter()
-        .map(|(_, ident, _)| quote!(#this_value::#ident))
+        .map(|(_, ident, _)| quote!(#this::#ident))
        .collect();

    let expecting = expecting.unwrap_or(if is_variant {
@@ -2400,8 +2391,7 @@ fn deserialize_struct_as_struct_visitor(
        .collect();

    let fields_stmt = {
-        let field_names = field_names_idents.iter().flat_map(|(_, _, aliases)| aliases);
-
+        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
        quote_block! {
            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
        }
@@ -2631,10 +2621,9 @@ fn deserialize_map(

    let mut result = quote!(#struct_path { #(#result),* });
    if params.has_getter {
-        let this_type = &params.this_type;
-        let (_, ty_generics, _) = params.generics.split_for_impl();
+        let this = &params.this;
        result = quote! {
-            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
+            _serde::__private::Into::<#this>::into(#result)
        };
    }

@@ -2814,15 +2803,15 @@ fn deserialize_map_in_place(
            }
        });

-    let this_type = &params.this_type;
+    let this = &params.this;
    let (_, _, ty_generics, _) = split_with_de_lifetime(params);

    let let_default = match cattrs.default() {
        attr::Default::Default => Some(quote!(
-            let __default: #this_type #ty_generics = _serde::__private::Default::default();
+            let __default: #this #ty_generics = _serde::__private::Default::default();
        )),
        attr::Default::Path(path) => Some(quote!(
-            let __default: #this_type #ty_generics = #path();
+            let __default: #this #ty_generics = #path();
        )),
        attr::Default::None => {
            // We don't need the default value, to prevent an unused variable warning
@@ -2855,7 +2844,7 @@ fn wrap_deserialize_with(
    value_ty: &TokenStream,
    deserialize_with: &syn::ExprPath,
 ) -> (TokenStream, TokenStream) {
-    let this_type = &params.this_type;
+    let this = &params.this;
    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
        split_with_de_lifetime(params);
    let delife = params.borrowed.de_lifetime();
@@ -2863,7 +2852,7 @@ fn wrap_deserialize_with(
    let wrapper = quote! {
        struct __DeserializeWith #de_impl_generics #where_clause {
            value: #value_ty,
-            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
            lifetime: _serde::__private::PhantomData<&#delife ()>,
        }

@@ -2914,7 +2903,7 @@ fn unwrap_to_variant_closure(
    variant: &Variant,
    with_wrapper: bool,
 ) -> TokenStream {
-    let this_value = &params.this_value;
+    let this = &params.this;
    let variant_ident = &variant.ident;

    let (arg, wrapper) = if with_wrapper {
@@ -2935,23 +2924,23 @@ fn unwrap_to_variant_closure(
        Style::Struct if variant.fields.len() == 1 => {
            let member = &variant.fields[0].member;
            quote! {
-                |#arg| #this_value::#variant_ident { #member: #wrapper }
+                |#arg| #this::#variant_ident { #member: #wrapper }
            }
        }
        Style::Struct => {
            let members = variant.fields.iter().map(|field| &field.member);
            quote! {
-                |#arg| #this_value::#variant_ident { #(#members: #wrapper.#field_access),* }
+                |#arg| #this::#variant_ident { #(#members: #wrapper.#field_access),* }
            }
        }
        Style::Tuple => quote! {
-            |#arg| #this_value::#variant_ident(#(#wrapper.#field_access),*)
+            |#arg| #this::#variant_ident(#(#wrapper.#field_access),*)
        },
        Style::Newtype => quote! {
-            |#arg| #this_value::#variant_ident(#wrapper)
+            |#arg| #this::#variant_ident(#wrapper)
        },
        Style::Unit => quote! {
-            |#arg| #this_value::#variant_ident
+            |#arg| #this::#variant_ident
        },
    }
 }
@@ -12,10 +12,10 @@ pub fn wrap_in_const(
 ) -> TokenStream {
    let try_replacement = try::replacement();

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

    let use_serde = match serde_path {
@@ -6,7 +6,6 @@ use syn::{Member, Type};
 /// Cross-cutting checks that require looking at more than a single attrs
 /// object. Simpler checks should happen when parsing and building the attrs.
 pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
-    check_remote_generic(cx, cont);
    check_getter(cx, cont);
    check_flatten(cx, cont);
    check_identifier(cx, cont);
@@ -17,28 +16,6 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
    check_from_and_try_from(cx, cont);
 }

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

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.153")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.137")]
 #![allow(unknown_lints, bare_trait_objects)]
 // Ignored clippy lints
 #![allow(
@@ -43,7 +43,7 @@
    clippy::enum_glob_use,
    clippy::indexing_slicing,
    clippy::items_after_statements,
-    clippy::let_underscore_untyped,
+    clippy::let_underscore_drop,
    clippy::manual_assert,
    clippy::map_err_ignore,
    clippy::match_same_arms,
@@ -68,12 +68,11 @@ extern crate quote;
 #[macro_use]
 extern crate syn;

-extern crate proc_macro;
 extern crate proc_macro2;

 mod internals;

-use proc_macro::TokenStream;
+use proc_macro2::TokenStream;
 use syn::DeriveInput;

 #[macro_use]
@@ -85,26 +84,29 @@ mod de;
 mod dummy;
 mod pretend;
 mod ser;
-mod this;
 mod try;

-#[proc_macro_derive(Serialize, attributes(serde))]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&mut input)
-        .unwrap_or_else(to_compile_errors)
-        .into()
+#[no_mangle]
+pub extern "C" fn derive_serialize(input: TokenStream) -> TokenStream {
+    let mut input: DeriveInput = match syn::parse2(input) {
+        Ok(input) => input,
+        Err(err) => return err.to_compile_error(),
+    };
+
+    ser::expand_derive_serialize(&mut input).unwrap_or_else(to_compile_errors)
 }

-#[proc_macro_derive(Deserialize, attributes(serde))]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&mut input)
-        .unwrap_or_else(to_compile_errors)
-        .into()
+#[no_mangle]
+pub extern "C" fn derive_deserialize(input: TokenStream) -> TokenStream {
+    let mut input: DeriveInput = match syn::parse2(input) {
+        Ok(input) => input,
+        Err(err) => return err.to_compile_error(),
+    };
+
+    de::expand_derive_deserialize(&mut input).unwrap_or_else(to_compile_errors)
 }

-fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
+fn to_compile_errors(errors: Vec<syn::Error>) -> TokenStream {
    let compile_errors = errors.iter().map(syn::Error::to_compile_error);
    quote!(#(#compile_errors)*)
 }
@@ -97,7 +97,7 @@ fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> Toke

    let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();

-    #[cfg(not(no_ptr_addr_of))]
+    #[cfg(ptr_addr_of)]
    {
        quote! {
            match _serde::__private::None::<&#type_ident #ty_generics> {
@@ -111,7 +111,7 @@ fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> Toke
        }
    }

-    #[cfg(no_ptr_addr_of)]
+    #[cfg(not(ptr_addr_of))]
    {
        let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));

@@ -8,7 +8,6 @@ use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, replace_receiver, Ctxt, Derive};
 use pretend;
-use this;

 pub fn expand_derive_serialize(
    input: &mut syn::DeriveInput,
@@ -83,13 +82,9 @@ struct Parameters {
    self_var: Ident,

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

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

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

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

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

    if variant.attrs.skip_serializing() {
@@ -447,32 +445,32 @@ fn serialize_variant(
            Style::Struct => quote!({ .. }),
        };
        quote! {
-            #this_value::#variant_ident #fields_pat => #skipped_err,
+            #this::#variant_ident #fields_pat => #skipped_err,
        }
    } else {
        // variant wasn't skipped
        let case = match variant.style {
            Style::Unit => {
                quote! {
-                    #this_value::#variant_ident
+                    #this::#variant_ident
                }
            }
            Style::Newtype => {
                quote! {
-                    #this_value::#variant_ident(ref __field0)
+                    #this::#variant_ident(ref __field0)
                }
            }
            Style::Tuple => {
                let field_names = (0..variant.fields.len())
                    .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                quote! {
-                    #this_value::#variant_ident(#(ref #field_names),*)
+                    #this::#variant_ident(#(ref #field_names),*)
                }
            }
            Style::Struct => {
                let members = variant.fields.iter().map(|f| &f.member);
                quote! {
-                    #this_value::#variant_ident { #(ref #members),* }
+                    #this::#variant_ident { #(ref #members),* }
                }
            }
        };
@@ -642,7 +640,7 @@ fn serialize_adjacently_tagged_variant(
    tag: &str,
    content: &str,
 ) -> Fragment {
-    let this_type = &params.this_type;
+    let this = &params.this;
    let type_name = cattrs.name().serialize_name();
    let variant_name = variant.attrs.name().serialize_name();

@@ -721,7 +719,7 @@ fn serialize_adjacently_tagged_variant(
    quote_block! {
        struct __AdjacentlyTagged #wrapper_generics #where_clause {
            data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
        }

        impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
@@ -743,7 +741,7 @@ fn serialize_adjacently_tagged_variant(
        try!(_serde::ser::SerializeStruct::serialize_field(
            &mut __struct, #content, &__AdjacentlyTagged {
                data: (#(#fields_ident,)*),
-                phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
+                phantom: _serde::__private::PhantomData::<#this #ty_generics>,
            }));
        _serde::ser::SerializeStruct::end(__struct)
    }
@@ -868,8 +866,8 @@ enum StructVariant<'a> {
    Untagged,
 }

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

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

@@ -984,7 +982,7 @@ fn serialize_struct_variant_with_flatten(
            quote_block! {
                struct __EnumFlatten #wrapper_generics #where_clause {
                    data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+                    phantom: _serde::__private::PhantomData<#this #ty_generics>,
                }

                impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
@@ -1008,7 +1006,7 @@ fn serialize_struct_variant_with_flatten(
                    #variant_name,
                    &__EnumFlatten {
                        data: (#(#members,)*),
-                        phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
+                        phantom: _serde::__private::PhantomData::<#this #ty_generics>,
                    })
            }
        }
@@ -1194,7 +1192,7 @@ fn wrap_serialize_with(
    field_tys: &[&syn::Type],
    field_exprs: &[TokenStream],
 ) -> TokenStream {
-    let this_type = &params.this_type;
+    let this = &params.this;
    let (_, ty_generics, where_clause) = params.generics.split_for_impl();

    let wrapper_generics = if field_exprs.is_empty() {
@@ -1214,7 +1212,7 @@ fn wrap_serialize_with(
    quote!({
        struct __SerializeWith #wrapper_impl_generics #where_clause {
            values: (#(&'__a #field_tys, )*),
-            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
        }

        impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
@@ -1228,7 +1226,7 @@ fn wrap_serialize_with(

        &__SerializeWith {
            values: (#(#field_exprs, )*),
-            phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
        }
    })
 }
@@ -1,32 +0,0 @@
-use internals::ast::Container;
-use syn::{Path, PathArguments, Token};
-
-pub fn this_type(cont: &Container) -> Path {
-    if let Some(remote) = cont.attrs.remote() {
-        let mut this = remote.clone();
-        for segment in &mut this.segments {
-            if let PathArguments::AngleBracketed(arguments) = &mut segment.arguments {
-                arguments.colon2_token = None;
-            }
-        }
-        this
-    } else {
-        Path::from(cont.ident.clone())
-    }
-}
-
-pub fn this_value(cont: &Container) -> Path {
-    if let Some(remote) = cont.attrs.remote() {
-        let mut this = remote.clone();
-        for segment in &mut this.segments {
-            if let PathArguments::AngleBracketed(arguments) = &mut segment.arguments {
-                if arguments.colon2_token.is_none() {
-                    arguments.colon2_token = Some(Token![::](arguments.lt_token.span));
-                }
-            }
-        }
-        this
-    } else {
-        Path::from(cont.ident.clone())
-    }
-}
@@ -2,14 +2,14 @@
 name = "serde_derive_internals"
 version = "0.26.0" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-description = "AST representation used by Serde derive macros. Unstable."
-documentation = "https://docs.rs/serde_derive_internals"
-homepage = "https://serde.rs"
-include = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
-keywords = ["serde", "serialization"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/serde-rs/serde"
 rust-version = "1.31"
+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 = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]

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

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
@@ -1,9 +1,6 @@
 use std::path::Path;

 fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-changed=src/mod.rs");
-
    // Sometimes on Windows the git checkout does not correctly wire up the
    // symlink from serde_derive_internals/src to serde_derive/src/internals.
    // When this happens we'll just build based on relative paths within the git
@@ -22,7 +22,7 @@
    clippy::doc_markdown,
    clippy::enum_glob_use,
    clippy::items_after_statements,
-    clippy::let_underscore_untyped,
+    clippy::let_underscore_drop,
    clippy::manual_assert,
    clippy::match_same_arms,
    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
@@ -1,18 +1,17 @@
 [package]
 name = "serde_test"
-version = "1.0.153" # remember to update html_root_url
+version = "1.0.137" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-build = "build.rs"
-categories = ["development-tools::testing"]
-description = "Token De/Serializer for testing De/Serialize implementations"
-documentation = "https://docs.rs/serde_test"
-homepage = "https://serde.rs"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-keywords = ["serde", "serialization", "testing", "dev-dependencies"]
+rust-version = "1.13"
 license = "MIT OR Apache-2.0"
-readme = "crates-io.md"
+description = "Token De/Serializer for testing De/Serialize implementations"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-rust-version = "1.19"
+documentation = "https://docs.serde.rs/serde_test/"
+keywords = ["serde", "serialization"]
+readme = "crates-io.md"
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+build = "build.rs"

 [dependencies]
 serde = { version = "1.0.60", path = "../serde" }
@@ -21,8 +20,5 @@ serde = { version = "1.0.60", path = "../serde" }
 serde = { version = "1.0", path = "../serde" }
 serde_derive = { version = "1.0", path = "../serde_derive" }

-[lib]
-doc-scrape-examples = false
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
@@ -6,8 +6,6 @@ use std::str::{self, FromStr};
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
    let minor = match rustc_minor_version() {
        Some(minor) => minor,
        None => return,
@@ -15,8 +13,8 @@ fn main() {

    // #[track_caller] stabilized in Rust 1.46:
    // https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html#track_caller
-    if minor < 46 {
-        println!("cargo:rustc-cfg=no_track_caller");
+    if minor >= 46 {
+        println!("cargo:rustc-cfg=track_caller");
    }
 }

@@ -28,7 +28,7 @@ use std::fmt::Debug;
 ///     Token::StructEnd,
 /// ]);
 /// ```
-#[cfg_attr(not(no_track_caller), track_caller)]
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
    T: Serialize + Deserialize<'de> + PartialEq + Debug,
@@ -59,7 +59,7 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
-#[cfg_attr(not(no_track_caller), track_caller)]
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_ser_tokens<T: ?Sized>(value: &T, tokens: &[Token])
 where
    T: Serialize,
@@ -112,7 +112,7 @@ where
 ///     assert_ser_tokens_error(&example, expected, error);
 /// }
 /// ```
-#[cfg_attr(not(no_track_caller), track_caller)]
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_ser_tokens_error<T: ?Sized>(value: &T, tokens: &[Token], error: &str)
 where
    T: Serialize,
@@ -150,7 +150,7 @@ where
 ///     Token::StructEnd,
 /// ]);
 /// ```
-#[cfg_attr(not(no_track_caller), track_caller)]
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
    T: Deserialize<'de> + PartialEq + Debug,
@@ -203,7 +203,7 @@ where
 ///     "unknown field `x`, expected `a` or `b`",
 /// );
 /// ```
-#[cfg_attr(not(no_track_caller), track_caller)]
+#[cfg_attr(track_caller, track_caller)]
 pub fn assert_de_tokens_error<'de, T>(tokens: &'de [Token], error: &str)
 where
    T: Deserialize<'de>,
@@ -1,8 +1,8 @@
 //! This crate provides a convenient concise way to write unit tests for
 //! implementations of [`Serialize`] and [`Deserialize`].
 //!
-//! [`Serialize`]: serde::ser::Serialize
-//! [`Deserialize`]: serde::de::Deserialize
+//! [`Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
+//! [`Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 //!
 //! The `Serialize` impl for a value can be characterized by the sequence of
 //! [`Serializer`] calls that are made in the course of serializing the value,
@@ -14,7 +14,11 @@
 //! test both directions. There are also functions to test expected failure
 //! conditions.
 //!
-//! [`Serializer`]: serde::ser::Serializer
+//! [`Serializer`]: https://docs.serde.rs/serde/ser/trait.Serializer.html
+//! [`Token`]: https://docs.serde.rs/serde_test/enum.Token.html
+//! [`assert_ser_tokens`]: https://docs.serde.rs/serde_test/fn.assert_ser_tokens.html
+//! [`assert_de_tokens`]: https://docs.serde.rs/serde_test/fn.assert_de_tokens.html
+//! [`assert_tokens`]: https://docs.serde.rs/serde_test/fn.assert_tokens.html
 //!
 //! Here is an example from the [`linked-hash-map`] crate.
 //!
@@ -140,7 +144,7 @@
 //! # }
 //! ```

-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.153")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.137")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
@@ -4,17 +4,26 @@ 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"
+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 = { path = "../serde", features = ["rc"] }
+wa-serde-derive = { path = "../wa-serde-derive" }
 serde_test = { path = "../serde_test" }
-trybuild = { version = "1.0.66", features = ["diff"] }
+trybuild = { version = "1.0.49", features = ["diff"] }
+
+[workspace]
@@ -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");
+    }
+}
@@ -1,7 +1,6 @@
 [package]
 name = "serde_derive_tests_no_std"
 version = "0.0.0"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 publish = false

@@ -1,3 +1,5 @@
+#![cfg(any())]
+
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[rustversion::attr(not(nightly), ignore)]
 #[cfg_attr(miri, ignore)]
@@ -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 },
+}
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -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>,
+}
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -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 },
+}
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -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);
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -0,0 +1,4 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+pub struct GenericTupleStruct<T, U>(T, U);
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -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 },
+}
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -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,
+}
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -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);
@@ -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,
+            )
+        }
+    }
+};
@@ -0,0 +1,4 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct NamedUnit;
@@ -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)
+                }
+            }
+        }
+    }
+};
@@ -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 },
+}
@@ -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,
+                },
+            )
+        }
+    }
+};
@@ -0,0 +1,4 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+enum Void {}
@@ -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");
+}
@@ -6,12 +6,12 @@
    clippy::nonstandard_macro_braces,
    clippy::too_many_lines,
    clippy::trivially_copy_pass_by_ref,
-    clippy::type_repetition_in_bounds,
-    clippy::uninlined_format_args,
+    clippy::type_repetition_in_bounds
 )]

 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_derive::{Deserialize, Serialize};

 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryFrom;
@@ -642,7 +642,7 @@ fn test_unknown_field_rename_struct() {
            Token::Str("a4"),
            Token::I32(3),
        ],
-        "unknown field `a4`, expected one of `a1`, `a3`, `a2`, `a5`, `a6`",
+        "unknown field `a4`, expected one of `a1`, `a2`, `a6`",
    );
 }

@@ -780,7 +780,7 @@ fn test_rename_enum() {
            Token::StructVariant {
                name: "AliasEnum",
                variant: "sailor_moon",
-                len: 5,
+                len: 3,
            },
            Token::Str("a"),
            Token::I8(0),
@@ -798,7 +798,7 @@ fn test_rename_enum() {
            Token::StructVariant {
                name: "AliasEnum",
                variant: "usagi_tsukino",
-                len: 5,
+                len: 3,
            },
            Token::Str("a"),
            Token::I8(0),
@@ -827,7 +827,7 @@ fn test_unknown_field_rename_enum() {
            Token::StructVariant {
                name: "AliasEnum",
                variant: "usagi_tsukino",
-                len: 5,
+                len: 3,
            },
            Token::Str("a"),
            Token::I8(0),
@@ -836,7 +836,7 @@ fn test_unknown_field_rename_enum() {
            Token::Str("d"),
            Token::I8(2),
        ],
-        "unknown field `d`, expected one of `a`, `c`, `b`, `e`, `f`",
+        "unknown field `d`, expected one of `a`, `b`, `f`",
    );
 }

@@ -1236,7 +1236,7 @@ fn serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> Result<S:
 where
    S: Serializer,
 {
-    serializer.collect_str(&format_args!("{};{:?}", f1, f2))
+    serializer.serialize_str(format!("{};{:?}", f1, f2).as_str())
 }

 fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
@@ -1245,17 +1245,22 @@ where
 {
    let s = String::deserialize(deserializer)?;
    let mut pieces = s.split(';');
-    let Some(f1) = pieces.next() else {
-        return Err(de::Error::invalid_length(0, &"2"));
+    let f1 = match pieces.next() {
+        Some(x) => x,
+        None => return Err(de::Error::invalid_length(0, &"2")),
    };
-    let Some(f2) = pieces.next() else {
-        return Err(de::Error::invalid_length(1, &"2"));
+    let f2 = match pieces.next() {
+        Some(x) => x,
+        None => return Err(de::Error::invalid_length(1, &"2")),
    };
-    let Ok(f2) = f2.parse() else {
-        return Err(de::Error::invalid_value(
-            Unexpected::Str(f2),
-            &"an 8-bit signed integer",
-        ));
+    let f2 = match f2.parse() {
+        Ok(n) => n,
+        Err(_) => {
+            return Err(de::Error::invalid_value(
+                Unexpected::Str(f2),
+                &"an 8-bit signed integer",
+            ));
+        }
    };
    Ok((f1.into(), f2))
 }
@@ -2298,25 +2303,6 @@ fn test_internally_tagged_enum_containing_flatten() {
    );
 }

-#[test]
-fn test_internally_tagged_enum_new_type_with_unit() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "t")]
-    enum Data {
-        A(()),
-    }
-
-    assert_tokens(
-        &Data::A(()),
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("t"),
-            Token::Str("A"),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_adjacently_tagged_enum_containing_flatten() {
    #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2658,68 +2644,6 @@ fn test_flatten_any_after_flatten_struct() {
    );
 }

-#[test]
-fn test_alias_in_flatten_context() {
-    #[derive(Debug, PartialEq, Deserialize)]
-    struct Outer {
-        #[serde(flatten)]
-        a: AliasStruct,
-        b: i32,
-    }
-
-    assert_de_tokens(
-        &Outer {
-            a: AliasStruct {
-                a1: 1,
-                a2: 2,
-                a4: 4,
-            },
-            b: 7,
-        },
-        &[
-            Token::Struct {
-                name: "Outer",
-                len: 4,
-            },
-            Token::Str("a1"),
-            Token::I32(1),
-            Token::Str("a2"),
-            Token::I32(2),
-            Token::Str("a5"),
-            Token::I32(4),
-            Token::Str("b"),
-            Token::I32(7),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &Outer {
-            a: AliasStruct {
-                a1: 1,
-                a2: 2,
-                a4: 4,
-            },
-            b: 7,
-        },
-        &[
-            Token::Struct {
-                name: "Outer",
-                len: 4,
-            },
-            Token::Str("a1"),
-            Token::I32(1),
-            Token::Str("a2"),
-            Token::I32(2),
-            Token::Str("a6"),
-            Token::I32(4),
-            Token::Str("b"),
-            Token::I32(7),
-            Token::StructEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_expecting_message() {
    #[derive(Deserialize, PartialEq, Debug)]
@@ -5,6 +5,7 @@
 )]

 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};

 use std::borrow::Cow;
@@ -5,7 +5,6 @@
    clippy::empty_enum,
    clippy::manual_assert,
    clippy::needless_pass_by_value,
-    clippy::uninlined_format_args,
    clippy::unreadable_literal
 )]
 #![cfg_attr(feature = "unstable", feature(never_type))]
@@ -35,6 +34,7 @@ use std::sync::atomic::{AtomicI64, AtomicU64};
 use fnv::FnvHasher;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Configure, Token};

 #[macro_use]
@@ -7,6 +7,7 @@

 use serde::de::IntoDeserializer;
 use serde::Deserialize;
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens_error, Token};
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::{CStr, CString};
@@ -2,12 +2,12 @@
 // successfully when there are a variety of generics and non-(de)serializable
 // types involved.

+#![cfg(any())]
 #![deny(warnings)]
 #![allow(
    unknown_lints,
    mixed_script_confusables,
    clippy::derive_partial_eq_without_eq,
-    clippy::extra_unused_type_parameters,
    clippy::items_after_statements,
    clippy::missing_errors_doc,
    clippy::missing_panics_doc,
@@ -2,7 +2,7 @@

 #![allow(clippy::derive_partial_eq_without_eq)]

-use serde::Deserialize;
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Token};

 #[test]
@@ -5,6 +5,7 @@ use serde::de::{
    DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
 };
 use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
+use serde_derive::Deserialize;

 #[derive(PartialEq, Debug, Deserialize)]
 enum Target {
@@ -8,7 +8,7 @@

 mod bytes;

-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 use serde_test::{
    assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, Token,
 };
@@ -1928,6 +1928,7 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
    );
 }

+#[deny(unaligned_references)]
 #[test]
 fn test_packed_struct_can_derive_serialize() {
    #[derive(Copy, Clone, Serialize)]
@@ -1,6 +1,6 @@
 #![allow(clippy::redundant_field_names)]

-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};

 mod remote {
    pub struct Unit;
@@ -74,21 +74,6 @@ mod remote {
            &self.b
        }
    }
-
-    pub struct StructGeneric<T> {
-        pub value: T,
-    }
-
-    impl<T> StructGeneric<T> {
-        #[allow(dead_code)]
-        pub fn get_value(&self) -> &T {
-            &self.value
-        }
-    }
-
-    pub enum EnumGeneric<T> {
-        Variant(T),
-    }
 }

 #[derive(Serialize, Deserialize)]
@@ -119,12 +104,6 @@ struct Test {

    #[serde(with = "StructPubDef")]
    struct_pub: remote::StructPub,
-
-    #[serde(with = "StructConcrete")]
-    struct_concrete: remote::StructGeneric<u8>,
-
-    #[serde(with = "EnumConcrete")]
-    enum_concrete: remote::EnumGeneric<u8>,
 }

 #[derive(Serialize, Deserialize)]
@@ -178,25 +157,6 @@ struct StructPubDef {
    b: remote::Unit,
 }

-#[derive(Serialize, Deserialize)]
-#[serde(remote = "remote::StructGeneric")]
-struct StructGenericWithGetterDef<T> {
-    #[serde(getter = "remote::StructGeneric::get_value")]
-    value: T,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(remote = "remote::StructGeneric<u8>")]
-struct StructConcrete {
-    value: u8,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(remote = "remote::EnumGeneric<u8>")]
-enum EnumConcrete {
-    Variant(u8),
-}
-
 impl From<PrimitivePrivDef> for remote::PrimitivePriv {
    fn from(def: PrimitivePrivDef) -> Self {
        remote::PrimitivePriv::new(def.0)
@@ -220,9 +180,3 @@ impl From<StructPrivDef> for remote::StructPriv {
        remote::StructPriv::new(def.a, def.b)
    }
 }
-
-impl<T> From<StructGenericWithGetterDef<T>> for remote::StructGeneric<T> {
-    fn from(def: StructGenericWithGetterDef<T>) -> Self {
-        remote::StructGeneric { value: def.value }
-    }
-}
@@ -1,6 +1,6 @@
 #![allow(clippy::used_underscore_binding)]

-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};

 #[test]
 fn test_self() {
@@ -13,7 +13,7 @@ use std::sync::atomic::{
    AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
    AtomicUsize,
 };
-use std::sync::{Arc, Mutex, RwLock, Weak as ArcWeak};
+use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};

 #[cfg(unix)]
@@ -22,7 +22,7 @@ use std::str;
 use std::sync::atomic::{AtomicI64, AtomicU64};

 use fnv::FnvHasher;
-use serde::Serialize;
+use serde_derive::Serialize;
 use serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};

 #[macro_use]
@@ -800,14 +800,17 @@ fn test_never_result() {
 #[test]
 #[cfg(unix)]
 fn test_cannot_serialize_paths() {
-    use std::ffi::OsStr;
-    use std::os::unix::ffi::OsStrExt;
-
+    let path = unsafe { str::from_utf8_unchecked(b"Hello \xF0\x90\x80World") };
    assert_ser_tokens_error(
-        &Path::new(OsStr::from_bytes(b"Hello \xF0\x90\x80World")),
+        &Path::new(path),
        &[],
        "path contains invalid UTF-8 characters",
    );
+
+    let mut path_buf = PathBuf::new();
+    path_buf.push(path);
+
+    assert_ser_tokens_error(&path_buf, &[], "path contains invalid UTF-8 characters");
 }

 #[test]
@@ -847,39 +850,3 @@ fn test_integer128() {

    assert_ser_tokens_error(&1u128, &[], "u128 is not supported");
 }
-
-#[test]
-fn test_refcell_dst() {
-    assert_ser_tokens(
-        &RefCell::new([true]) as &RefCell<[bool]>,
-        &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_mutex_dst() {
-    assert_ser_tokens(
-        &Mutex::new([true]) as &Mutex<[bool]>,
-        &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_rwlock_dst() {
-    assert_ser_tokens(
-        &RwLock::new([true]) as &RwLock<[bool]>,
-        &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
-        ],
-    );
-}
@@ -1,11 +1,8 @@
-#![allow(
-    clippy::extra_unused_type_parameters,
-    clippy::type_repetition_in_bounds
-)]
+#![allow(clippy::type_repetition_in_bounds)]

 #[test]
 fn test_gen_custom_serde() {
-    #[derive(serde::Serialize, serde::Deserialize)]
+    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
    #[serde(crate = "fake_serde")]
    struct Foo;

@@ -3,6 +3,7 @@
 use serde::de::value::{self, MapAccessDeserializer};
 use serde::de::{IntoDeserializer, MapAccess, Visitor};
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 use std::fmt;

@@ -1,17 +0,0 @@
-use serde_derive::{Deserialize, Serialize};
-
-mod remote {
-    pub struct Struct<T, U> {
-        pub t: T,
-        pub u: U,
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(remote = "remote::StructGeneric<u8>")]
-struct StructDef<U> {
-    t: u8,
-    u: U,
-}
-
-fn main() {}
@@ -1,5 +0,0 @@
-error: remove generic parameters from this path
-  --> tests/ui/remote/double_generic.rs:11:18
-   |
-11 | #[serde(remote = "remote::StructGeneric<u8>")]
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -4,7 +4,7 @@ error[E0308]: mismatched types
 15 | #[derive(Serialize)]
   |          ^^^^^^^^^
   |          |
-   |          expected `&u8`, found `&u16`
+   |          expected `u8`, found `u16`
   |          arguments to this function are incorrect
   |
   = note: expected reference `&u8`
@@ -1,17 +1,17 @@
 error[E0308]: mismatched types
- --> tests/ui/remote/wrong_ser.rs:9:10
-  |
-9 | #[derive(Serialize)]
-  |          ^^^^^^^^^
-  |          |
-  |          expected `&u8`, found `&u16`
-  |          arguments to this function are incorrect
-  |
-  = note: expected reference `&u8`
-             found reference `&u16`
+  --> tests/ui/remote/wrong_ser.rs:9:10
+   |
+9  | #[derive(Serialize)]
+   |          ^^^^^^^^^
+   |          |
+   |          expected `u8`, found `u16`
+   |          arguments to this function are incorrect
+   |
+   = note: expected reference `&u8`
+              found reference `&u16`
 note: function defined here
- --> $WORKSPACE/serde/src/private/ser.rs
-  |
-  | pub fn constrain<T: ?Sized>(t: &T) -> &T {
-  |        ^^^^^^^^^
-  = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)
+  --> $WORKSPACE/serde/src/private/ser.rs
+   |
+   | pub fn constrain<T: ?Sized>(t: &T) -> &T {
+   |        ^^^^^^^^^
+   = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -0,0 +1 @@
+*.wasm
@@ -0,0 +1,17 @@
+[package]
+name = "wa-serde-derive"
+version = "0.1.137"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+license = "MIT OR Apache-2.0"
+description = "serde_derive compiled to wasm"
+repository = "https://github.com/dtolnay/watt"
+include = ["src"]
+
+[lib]
+name = "serde_derive"
+proc-macro = true
+
+[dependencies]
+watt = "0.4"
+
+[workspace]
@@ -0,0 +1,18 @@
+extern crate proc_macro;
+extern crate watt;
+
+use proc_macro::TokenStream;
+use watt::WasmMacro;
+
+static MACRO: WasmMacro = WasmMacro::new(WASM);
+static WASM: &[u8] = include_bytes!("serde_derive.wasm");
+
+#[proc_macro_derive(Serialize, attributes(serde))]
+pub fn derive_serialize(input: TokenStream) -> TokenStream {
+    MACRO.proc_macro_derive("derive_serialize", input)
+}
+
+#[proc_macro_derive(Deserialize, attributes(serde))]
+pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+    MACRO.proc_macro_derive("derive_deserialize", input)
+}
Author	SHA1	Message	Date
David Tolnay	af31449cb1	Run test suite on wa-serde-derive	2022-07-01 17:56:18 -07:00
David Tolnay	1afae183b0	Compile serde_derive to wasm	2022-07-01 17:55:51 -07:00