Release 1.0.106

Hide generated dummy const in rustdoc

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.103" # remember to update html_root_url and serde_derive dependency
+version = "1.0.106" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -18,7 +18,7 @@ travis-ci = { repository = "serde-rs/serde" }
 appveyor = { repository = "serde-rs/serde" }
 
 [dependencies]
-serde_derive = { version = "=1.0.103", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.106", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }
@@ -26,6 +26,9 @@ serde_derive = { version = "1.0", path = "../serde_derive" }
 [package.metadata.playground]
 features = ["derive", "rc"]
 
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
 
 ### FEATURES #################################################################
 

serde/src/lib.rs

@@ -75,14 +75,14 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.103")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.106")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and
 // discussion of these features please refer to this issue:
 //
 //    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(specialization))]
+#![cfg_attr(feature = "unstable", feature(specialization, never_type))]
 #![allow(unknown_lints, bare_trait_objects, deprecated)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
@@ -106,19 +106,25 @@
         type_complexity,
         use_self,
         zero_prefixed_literal,
+        // correctly used
+        enum_glob_use,
+        wildcard_imports,
         // not practical
         needless_pass_by_value,
         similar_names,
         too_many_lines,
         // preference
         doc_markdown,
+        unseparated_literal_suffix,
         // false positive
         needless_doctest_main,
         // noisy
+        missing_errors_doc,
         must_use_candidate,
     )
 )]
 // Rustc lints.
+#![forbid(unsafe_code)]
 #![deny(missing_docs, unused_imports)]
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/private/de.rs

@@ -53,9 +53,10 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub fn borrow_cow_str<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, str>, D::Error>
+pub fn borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
 where
     D: Deserializer<'de>,
+    R: From<Cow<'a, str>>,
 {
     struct CowStrVisitor;
 
@@ -121,13 +122,14 @@ where
         }
     }
 
-    deserializer.deserialize_str(CowStrVisitor)
+    deserializer.deserialize_str(CowStrVisitor).map(From::from)
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub fn borrow_cow_bytes<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, [u8]>, D::Error>
+pub fn borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
 where
     D: Deserializer<'de>,
+    R: From<Cow<'a, [u8]>>,
 {
     struct CowBytesVisitor;
 
@@ -181,7 +183,7 @@ where
         }
     }
 
-    deserializer.deserialize_bytes(CowBytesVisitor)
+    deserializer.deserialize_bytes(CowBytesVisitor).map(From::from)
 }
 
 pub mod size_hint {

serde/src/ser/impls.rs

@@ -633,8 +633,7 @@ impl Serialize for SystemTime {
 #[cfg(feature = "std")]
 macro_rules! serialize_display_bounded_length {
     ($value:expr, $max:expr, $serializer:expr) => {{
-        #[allow(deprecated)]
-        let mut buffer: [u8; $max] = unsafe { mem::uninitialized() };
+        let mut buffer = [0u8; $max];
         let remaining_len = {
             let mut remaining = &mut buffer[..];
             write!(remaining, "{}", $value).unwrap();
@@ -646,7 +645,7 @@ macro_rules! serialize_display_bounded_length {
         // write! only provides fmt::Formatter to Display implementations, which
         // has methods write_str and write_char but no method to write arbitrary
         // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = unsafe { str::from_utf8_unchecked(written) };
+        let written_str = str::from_utf8(written).expect("must be valid UTF-8");
         $serializer.serialize_str(written_str)
     }};
 }

serde/src/ser/mod.rs

@@ -1359,10 +1359,7 @@ pub trait Serializer: Sized {
     where
         T: Display,
     {
-        use lib::fmt::Write;
-        let mut string = String::new();
-        write!(string, "{}", value).unwrap();
-        self.serialize_str(&string)
+        self.serialize_str(&value.to_string())
     }
 
     /// Serialize a string produced by an implementation of `Display`.

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.103" # remember to update html_root_url
+version = "1.0.106" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -30,3 +30,6 @@ syn = { version = "1.0", features = ["visit"] }
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

serde_derive/src/de.rs

@@ -310,12 +310,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
 
     let code = match &cont.data {
         Data::Struct(Style::Struct, fields) => {
-            if let Some(code) = deserialize_struct_in_place(None, params, fields, &cont.attrs, None)
-            {
-                code
-            } else {
-                return None;
-            }
+            deserialize_struct_in_place(None, params, fields, &cont.attrs, None)?
         }
         Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
             deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)

serde_derive/src/dummy.rs

@@ -29,6 +29,7 @@ pub fn wrap_in_const(
     };
 
     quote! {
+        #[doc(hidden)]
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
         const #dummy_const: () = {
             #use_serde

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.103")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.106")]
 #![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
@@ -28,6 +28,7 @@
         too_many_arguments,
         trivially_copy_pass_by_ref,
         used_underscore_binding,
+        wildcard_in_or_patterns,
     )
 )]
 // Ignored clippy_pedantic lints
@@ -46,9 +47,11 @@
         must_use_candidate,
         similar_names,
         single_match_else,
+        struct_excessive_bools,
         too_many_lines,
         unseparated_literal_suffix,
         use_self,
+        wildcard_imports,
     )
 )]
 // The `quote!` macro requires deep recursion.

serde_derive/src/ser.rs

@@ -870,9 +870,9 @@ fn serialize_struct_variant<'a>(
     }
 
     let struct_trait = match context {
-        StructVariant::ExternallyTagged { .. } => (StructTrait::SerializeStructVariant),
+        StructVariant::ExternallyTagged { .. } => StructTrait::SerializeStructVariant,
         StructVariant::InternallyTagged { .. } | StructVariant::Untagged => {
-            (StructTrait::SerializeStruct)
+            StructTrait::SerializeStruct
         }
     };
 
@@ -1273,9 +1273,15 @@ enum StructTrait {
 impl StructTrait {
     fn serialize_field(&self, span: Span) -> TokenStream {
         match *self {
-            StructTrait::SerializeMap => quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry),
-            StructTrait::SerializeStruct => quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field),
-            StructTrait::SerializeStructVariant => quote_spanned!(span=> _serde::ser::SerializeStructVariant::serialize_field),
+            StructTrait::SerializeMap => {
+                quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry)
+            }
+            StructTrait::SerializeStruct => {
+                quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field)
+            }
+            StructTrait::SerializeStructVariant => {
+                quote_spanned!(span=> _serde::ser::SerializeStructVariant::serialize_field)
+            }
         }
     }
 
@@ -1301,9 +1307,15 @@ enum TupleTrait {
 impl TupleTrait {
     fn serialize_element(&self, span: Span) -> TokenStream {
         match *self {
-            TupleTrait::SerializeTuple => quote_spanned!(span=> _serde::ser::SerializeTuple::serialize_element),
-            TupleTrait::SerializeTupleStruct => quote_spanned!(span=> _serde::ser::SerializeTupleStruct::serialize_field),
-            TupleTrait::SerializeTupleVariant => quote_spanned!(span=> _serde::ser::SerializeTupleVariant::serialize_field),
+            TupleTrait::SerializeTuple => {
+                quote_spanned!(span=> _serde::ser::SerializeTuple::serialize_element)
+            }
+            TupleTrait::SerializeTupleStruct => {
+                quote_spanned!(span=> _serde::ser::SerializeTupleStruct::serialize_field)
+            }
+            TupleTrait::SerializeTupleVariant => {
+                quote_spanned!(span=> _serde::ser::SerializeTupleVariant::serialize_field)
+            }
         }
     }
 }

serde_derive_internals/Cargo.toml

@@ -21,3 +21,6 @@ syn = { version = "1.0", default-features = false, features = ["derive", "parsin
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
 appveyor = { repository = "serde-rs/serde" }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/lib.rs

@@ -6,7 +6,8 @@
     allow(
         cognitive_complexity,
         redundant_field_names,
-        trivially_copy_pass_by_ref
+        trivially_copy_pass_by_ref,
+        wildcard_in_or_patterns
     )
 )]
 

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.103" # remember to update html_root_url
+version = "1.0.106" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -21,3 +21,6 @@ serde_derive = { version = "1.0", path = "../serde_derive" }
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
 appveyor = { repository = "serde-rs/serde" }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

serde_test/src/lib.rs

@@ -144,7 +144,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.103")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.106")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints

test_suite/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.0.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 edition = "2018"
 publish = false
+build = "build.rs"
 
 [features]
 unstable = ["serde/unstable"]
@@ -18,3 +19,4 @@ serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
 trybuild = "1.0"
+macrotest = "0.1"

test_suite/build.rs

@@ -0,0 +1,22 @@
+use std::process::{Command, ExitStatus, Stdio};
+
+#[cfg(not(windows))]
+const CARGO_EXPAND: &str = "cargo-expand";
+
+#[cfg(windows)]
+const CARGO_EXPAND: &str = "cargo-expand.exe";
+
+fn main() {
+    if Command::new(CARGO_EXPAND)
+        .arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .as_ref()
+        .map(ExitStatus::success)
+        .unwrap_or(false)
+    {
+        println!("cargo:rustc-cfg=cargo_expand");
+    }
+}

test_suite/tests/compiletest.rs

@@ -1,4 +1,4 @@
-#[cfg(not(target_os = "emscripten"))]
+#[cfg_attr(target_os = "emscripten", ignore)]
 #[rustversion::attr(not(nightly), ignore)]
 #[test]
 fn ui() {

test_suite/tests/expand/de_enum.rs

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

test_suite/tests/expand/default_ty_param.expanded.rs

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

test_suite/tests/expand/default_ty_param.rs

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

test_suite/tests/expand/generic_enum.expanded.rs

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

test_suite/tests/expand/generic_enum.rs

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

test_suite/tests/expand/generic_struct.expanded.rs

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

test_suite/tests/expand/generic_struct.rs

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

test_suite/tests/expand/generic_tuple_struct.expanded.rs

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

test_suite/tests/expand/generic_tuple_struct.rs

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

test_suite/tests/expand/lifetimes.expanded.rs

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

test_suite/tests/expand/lifetimes.rs

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

test_suite/tests/expand/named_map.expanded.rs

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

test_suite/tests/expand/named_map.rs

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

test_suite/tests/expand/named_tuple.expanded.rs

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

test_suite/tests/expand/named_tuple.rs

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

test_suite/tests/expand/named_unit.expanded.rs

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

test_suite/tests/expand/named_unit.rs

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

test_suite/tests/expand/ser_enum.expanded.rs

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

test_suite/tests/expand/ser_enum.rs

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

test_suite/tests/expand/void.expanded.rs

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

test_suite/tests/expand/void.rs

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

test_suite/tests/expandtest.rs

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

test_suite/tests/test_de.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::decimal_literal_representation, clippy::unreadable_literal)]
+#![cfg_attr(feature = "unstable", feature(never_type))]
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::default::Default;

test_suite/tests/test_ser.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::unreadable_literal)]
+#![cfg_attr(feature = "unstable", feature(never_type))]
 
 use std::cell::RefCell;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};

test_suite/tests/ui/remote/missing_field.stderr

@@ -3,5 +3,3 @@ error[E0063]: missing field `b` in initializer of `remote::S`
    |
 11 | #[serde(remote = "remote::S")]
    |                  ^^^^^^^^^^^ missing `b`
-
-For more information about this error, try `rustc --explain E0063`.

test_suite/tests/ui/remote/unknown_field.stderr

@@ -9,6 +9,3 @@ error[E0560]: struct `remote::S` has no field named `b`
    |
 12 |     b: u8,
    |     ^ help: a field with a similar name exists: `a`
-
-Some errors have detailed explanations: E0560, E0609.
-For more information about an error, try `rustc --explain E0560`.

test_suite/tests/ui/remote/wrong_de.stderr

@@ -4,7 +4,7 @@ error[E0308]: mismatched types
 7 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^
   |          |
-  |          expected u16, found u8
+  |          expected `u16`, found `u8`
   |          help: you can convert an `u8` to `u16`: `Deserialize.into()`
-
-For more information about this error, try `rustc --explain E0308`.
+  |
+  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)

test_suite/tests/ui/remote/wrong_getter.stderr

@@ -2,7 +2,8 @@ error[E0308]: mismatched types
   --> $DIR/wrong_getter.rs:15:10
    |
 15 | #[derive(Serialize)]
-   |          ^^^^^^^^^ expected u8, found u16
+   |          ^^^^^^^^^ expected `u8`, found `u16`
    |
-   = note: expected type `&u8`
-              found type `&u16`
+   = note: expected reference `&u8`
+              found reference `&u16`
+   = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)

test_suite/tests/ui/remote/wrong_ser.stderr

@@ -2,9 +2,8 @@ error[E0308]: mismatched types
  --> $DIR/wrong_ser.rs:9:10
   |
 9 | #[derive(Serialize)]
-  |          ^^^^^^^^^ expected u8, found u16
+  |          ^^^^^^^^^ expected `u8`, found `u16`
   |
-  = note: expected type `&u8`
-             found type `&u16`
-
-For more information about this error, try `rustc --explain E0308`.
+  = note: expected reference `&u8`
+             found reference `&u16`
+  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)

test_suite/tests/ui/struct-representation/internally-tagged-unit.stderr

@@ -3,3 +3,5 @@ error: #[serde(tag = "...")] can only be used on enums and structs with named fi
   |
 3 | #[derive(Serialize)]
   |          ^^^^^^^^^
+  |
+  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)