Release 1.0.179

warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2870:25
         |
    2870 |             /// Reaches crate::private::de::content::VariantDeserializer::tuple_variant
         |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
         = note: `-W clippy::doc-markdown` implied by `-W clippy::pedantic`
    help: try
         |
    2870 |             /// Reaches `crate::private::de::content::VariantDeserializer::tuple_variant`
         |                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2871:17
         |
    2871 |             /// Content::Seq case
         |                 ^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2871 |             /// `Content::Seq` case
         |                 ~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2872:21
         |
    2872 |             /// via FlatMapDeserializer::deserialize_enum
         |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2872 |             /// via `FlatMapDeserializer::deserialize_enum`
         |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2894:25
         |
    2894 |             /// Reaches crate::private::de::content::VariantDeserializer::struct_variant
         |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2894 |             /// Reaches `crate::private::de::content::VariantDeserializer::struct_variant`
         |                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2895:17
         |
    2895 |             /// Content::Seq case
         |                 ^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2895 |             /// `Content::Seq` case
         |                 ~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2896:21
         |
    2896 |             /// via FlatMapDeserializer::deserialize_enum
         |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2896 |             /// via `FlatMapDeserializer::deserialize_enum`
         |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2921:25
         |
    2921 |             /// Reaches crate::private::de::content::VariantDeserializer::struct_variant
         |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2921 |             /// Reaches `crate::private::de::content::VariantDeserializer::struct_variant`
         |                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2922:17
         |
    2922 |             /// Content::Map case
         |                 ^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2922 |             /// `Content::Map` case
         |                 ~~~~~~~~~~~~~~

    warning: item in documentation is missing backticks
        --> test_suite/tests/test_annotations.rs:2923:21
         |
    2923 |             /// via FlatMapDeserializer::deserialize_enum
         |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
    help: try
         |
    2923 |             /// via `FlatMapDeserializer::deserialize_enum`
         |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.github/workflows/ci.yml

@@ -62,6 +62,7 @@ jobs:
       - run: cd serde && cargo build --no-default-features
       - run: cd serde && cargo build --no-default-features --features alloc
       - run: cd serde && cargo build --no-default-features --features rc,alloc
+      - run: cd serde && cargo build --no-default-features --features unstable
       - run: cd serde && cargo test --features derive,rc,unstable
       - run: cd test_suite/no_std && cargo build
         if: matrix.os != 'windows'

precompiled/bin/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.177"
+version = "1.0.179"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 publish = false
 

precompiled/serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.177"
+version = "1.0.179"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 categories = ["no-std", "no-std::no-alloc"]
 description = "Implementation of #[derive(Serialize, Deserialize)]"

precompiled/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.177")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.179")]
 
 #[cfg(not(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu")))]
 include!("lib_from_source.rs");

precompiled/serde_derive/src/lib_from_source.rs

@@ -14,7 +14,6 @@ mod internals;
 mod pretend;
 mod ser;
 mod this;
-mod try;
 
 use proc_macro::TokenStream;
 use syn::{parse_macro_input, DeriveInput};

precompiled/serde_derive/src/try.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/try.rs

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.177" # remember to update html_root_url and serde_derive dependency
+version = "1.0.179" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
@@ -14,7 +14,7 @@ repository = "https://github.com/serde-rs/serde"
 rust-version = "1.19"
 
 [dependencies]
-serde_derive = { version = "=1.0.177", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.179", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1", path = "../serde_derive" }

serde/src/de/mod.rs

@@ -126,10 +126,13 @@ mod utf8;
 
 pub use self::ignored_any::IgnoredAny;
 
+#[cfg(all(feature = "unstable", not(feature = "std")))]
+#[doc(no_inline)]
+pub use core::error::Error as StdError;
 #[cfg(feature = "std")]
 #[doc(no_inline)]
 pub use std::error::Error as StdError;
-#[cfg(not(feature = "std"))]
+#[cfg(not(any(feature = "std", feature = "unstable")))]
 #[doc(no_inline)]
 pub use std_error::Error as StdError;
 

serde/src/lib.rs

@@ -93,7 +93,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.177")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.179")]
 // 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
@@ -149,6 +149,8 @@
         must_use_candidate,
     )
 )]
+// Restrictions
+#![cfg_attr(feature = "cargo-clippy", deny(question_mark_used))]
 // Rustc lints.
 #![deny(missing_docs, unused_imports)]
 

serde/src/private/de.rs

@@ -207,6 +207,7 @@ mod content {
 
     use __private::size_hint;
     use actually_private;
+    use de::value::{MapDeserializer, SeqDeserializer};
     use de::{
         self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
         MapAccess, SeqAccess, Unexpected, Visitor,
@@ -299,6 +300,17 @@ mod content {
         }
     }
 
+    impl<'de, E> de::IntoDeserializer<'de, E> for Content<'de>
+    where
+        E: de::Error,
+    {
+        type Deserializer = ContentDeserializer<'de, E>;
+
+        fn into_deserializer(self) -> Self::Deserializer {
+            ContentDeserializer::new(self)
+        }
+    }
+
     struct ContentVisitor<'de> {
         value: PhantomData<Content<'de>>,
     }
@@ -1074,7 +1086,7 @@ mod content {
         E: de::Error,
     {
         let seq = content.into_iter().map(ContentDeserializer::new);
-        let mut seq_visitor = de::value::SeqDeserializer::new(seq);
+        let mut seq_visitor = SeqDeserializer::new(seq);
         let value = try!(visitor.visit_seq(&mut seq_visitor));
         try!(seq_visitor.end());
         Ok(value)
@@ -1091,7 +1103,7 @@ mod content {
         let map = content
             .into_iter()
             .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
-        let mut map_visitor = de::value::MapDeserializer::new(map);
+        let mut map_visitor = MapDeserializer::new(map);
         let value = try!(visitor.visit_map(&mut map_visitor));
         try!(map_visitor.end());
         Ok(value)
@@ -1569,7 +1581,7 @@ mod content {
         {
             match self.value {
                 Some(Content::Seq(v)) => {
-                    de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
+                    de::Deserializer::deserialize_any(SeqDeserializer::new(v.into_iter()), visitor)
                 }
                 Some(other) => Err(de::Error::invalid_type(
                     other.unexpected(),
@@ -1592,10 +1604,10 @@ mod content {
         {
             match self.value {
                 Some(Content::Map(v)) => {
-                    de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
+                    de::Deserializer::deserialize_any(MapDeserializer::new(v.into_iter()), visitor)
                 }
                 Some(Content::Seq(v)) => {
-                    de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
+                    de::Deserializer::deserialize_any(SeqDeserializer::new(v.into_iter()), visitor)
                 }
                 Some(other) => Err(de::Error::invalid_type(
                     other.unexpected(),
@@ -1609,156 +1621,6 @@ mod content {
         }
     }
 
-    struct SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        iter: <Vec<Content<'de>> as IntoIterator>::IntoIter,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        fn new(vec: Vec<Content<'de>>) -> Self {
-            SeqDeserializer {
-                iter: vec.into_iter(),
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, E> de::Deserializer<'de> for SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        #[inline]
-        fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            let len = self.iter.len();
-            if len == 0 {
-                visitor.visit_unit()
-            } else {
-                let ret = try!(visitor.visit_seq(&mut self));
-                let remaining = self.iter.len();
-                if remaining == 0 {
-                    Ok(ret)
-                } else {
-                    Err(de::Error::invalid_length(len, &"fewer elements in array"))
-                }
-            }
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf option unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
-    impl<'de, E> de::SeqAccess<'de> for SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.iter.next() {
-                Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
-                None => Ok(None),
-            }
-        }
-
-        fn size_hint(&self) -> Option<usize> {
-            size_hint::from_bounds(&self.iter)
-        }
-    }
-
-    struct MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        iter: <Vec<(Content<'de>, Content<'de>)> as IntoIterator>::IntoIter,
-        value: Option<Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        fn new(map: Vec<(Content<'de>, Content<'de>)>) -> Self {
-            MapDeserializer {
-                iter: map.into_iter(),
-                value: None,
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, E> de::MapAccess<'de> for MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.iter.next() {
-                Some((key, value)) => {
-                    self.value = Some(value);
-                    seed.deserialize(ContentDeserializer::new(key)).map(Some)
-                }
-                None => Ok(None),
-            }
-        }
-
-        fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.value.take() {
-                Some(value) => seed.deserialize(ContentDeserializer::new(value)),
-                None => Err(de::Error::custom("value is missing")),
-            }
-        }
-
-        fn size_hint(&self) -> Option<usize> {
-            size_hint::from_bounds(&self.iter)
-        }
-    }
-
-    impl<'de, E> de::Deserializer<'de> for MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        #[inline]
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            visitor.visit_map(self)
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf option unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
     /// Not public API.
     pub struct ContentRefDeserializer<'a, 'de: 'a, E> {
         content: &'a Content<'de>,
@@ -1820,7 +1682,7 @@ mod content {
         E: de::Error,
     {
         let seq = content.iter().map(ContentRefDeserializer::new);
-        let mut seq_visitor = de::value::SeqDeserializer::new(seq);
+        let mut seq_visitor = SeqDeserializer::new(seq);
         let value = try!(visitor.visit_seq(&mut seq_visitor));
         try!(seq_visitor.end());
         Ok(value)
@@ -1840,7 +1702,7 @@ mod content {
                 ContentRefDeserializer::new(v),
             )
         });
-        let mut map_visitor = de::value::MapDeserializer::new(map);
+        let mut map_visitor = MapDeserializer::new(map);
         let value = try!(visitor.visit_map(&mut map_visitor));
         try!(map_visitor.end());
         Ok(value)

serde/src/private/ser.rs

@@ -1025,7 +1025,7 @@ where
     type SerializeTupleStruct = Impossible<Self::Ok, M::Error>;
     type SerializeMap = FlatMapSerializeMap<'a, M>;
     type SerializeStruct = FlatMapSerializeStruct<'a, M>;
-    type SerializeTupleVariant = Impossible<Self::Ok, M::Error>;
+    type SerializeTupleVariant = FlatMapSerializeTupleVariantAsMapValue<'a, M>;
     type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a, M>;
 
     fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
@@ -1157,10 +1157,11 @@ where
         self,
         _: &'static str,
         _: u32,
-        _: &'static str,
+        variant: &'static str,
         _: usize,
     ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(Self::bad_type(Unsupported::Enum))
+        try!(self.0.serialize_key(variant));
+        Ok(FlatMapSerializeTupleVariantAsMapValue::new(self.0))
     }
 
     fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
@@ -1259,6 +1260,52 @@ where
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeTupleVariantAsMapValue<'a, M: 'a> {
+    map: &'a mut M,
+    fields: Vec<Content>,
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> FlatMapSerializeTupleVariantAsMapValue<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    fn new(map: &'a mut M) -> Self {
+        FlatMapSerializeTupleVariantAsMapValue {
+            map,
+            fields: Vec::new(),
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeTupleVariant for FlatMapSerializeTupleVariantAsMapValue<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
+        self.fields.push(value);
+        Ok(())
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        try!(self.map.serialize_value(&Content::Seq(self.fields)));
+        Ok(())
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub struct FlatMapSerializeStructVariantAsMapValue<'a, M: 'a> {
     map: &'a mut M,

serde/src/ser/mod.rs

@@ -116,7 +116,7 @@ mod impossible;
 pub use self::impossible::Impossible;
 
 #[cfg(all(feature = "unstable", not(feature = "std")))]
-#[doc(inline)]
+#[doc(no_inline)]
 pub use core::error::Error as StdError;
 #[cfg(feature = "std")]
 #[doc(no_inline)]

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.177" # remember to update html_root_url
+version = "1.0.179" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 categories = ["no-std", "no-std::no-alloc"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"

serde_derive/src/de.rs

@@ -710,14 +710,14 @@ fn deserialize_seq(
                     let span = field.original.span();
                     let func =
                         quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
-                    quote!(try!(#func(&mut __seq)))
+                    quote!(#func(&mut __seq)?)
                 }
                 Some(path) => {
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
                         _serde::__private::Option::map(
-                            try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)),
+                            _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)?,
                             |__wrap| __wrap.value)
                     })
                 }
@@ -824,8 +824,8 @@ fn deserialize_seq_in_place(
             let write = match field.attrs.deserialize_with() {
                 None => {
                     quote! {
-                        if let _serde::__private::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
+                        if let _serde::__private::None = _serde::de::SeqAccess::next_element_seed(&mut __seq,
-                            _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
+                            _serde::__private::de::InPlaceSeed(&mut self.place.#member))?
                         {
                             #value_if_none
                         }
@@ -835,7 +835,7 @@ fn deserialize_seq_in_place(
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
-                        match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
+                        match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)? {
                             _serde::__private::Some(__wrap) => {
                                 self.place.#member = __wrap.value;
                             }
@@ -887,12 +887,12 @@ fn deserialize_newtype_struct(
             let span = field.original.span();
             let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote! {
-                try!(#func(__e))
+                #func(__e)?
             }
         }
         Some(path) => {
             quote! {
-                try!(#path(__e))
+                #path(__e)?
             }
         }
     };
@@ -1364,7 +1364,7 @@ fn deserialize_externally_tagged_enum(
         }
     } else {
         quote! {
-            match try!(_serde::de::EnumAccess::variant(__data)) {
+            match _serde::de::EnumAccess::variant(__data)? {
                 #(#variant_arms)*
             }
         }
@@ -1444,9 +1444,9 @@ fn deserialize_internally_tagged_enum(
 
         #variants_stmt
 
-        let (__tag, __content) = try!(_serde::Deserializer::deserialize_any(
+        let (__tag, __content) = _serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting)));
+            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?;
         let __deserializer = _serde::__private::de::ContentDeserializer::<__D::Error>::new(__content);
 
         match __tag {
@@ -1554,7 +1554,7 @@ fn deserialize_adjacently_tagged_enum(
 
     // Advance the map by one key, returning early in case of error.
     let next_key = quote! {
-        try!(_serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content))
+        _serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content)?
     };
 
     // When allowing unknown fields, we want to transparently step through keys
@@ -1567,7 +1567,7 @@ fn deserialize_adjacently_tagged_enum(
             while let _serde::__private::Some(__k) = #next_key {
                 match __k {
                     _serde::__private::de::TagContentOtherField::Other => {
-                        let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
+                        let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?;
                         continue;
                     },
                     _serde::__private::de::TagContentOtherField::Tag => {
@@ -1602,14 +1602,14 @@ fn deserialize_adjacently_tagged_enum(
 
     let finish_content_then_tag = if variant_arms.is_empty() {
         quote! {
-            match try!(_serde::de::MapAccess::next_value::<__Field>(&mut __map)) {}
+            match _serde::de::MapAccess::next_value::<__Field>(&mut __map)? {}
         }
     } else {
         quote! {
-            let __ret = try!(match try!(_serde::de::MapAccess::next_value(&mut __map)) {
+            let __ret = match _serde::de::MapAccess::next_value(&mut __map)? {
                 // Deserialize the buffered content now that we know the variant.
                 #(#variant_arms)*
-            });
+            }?;
             // Visit remaining keys, looking for duplicates.
             #visit_remaining_keys
         }
@@ -1662,7 +1662,7 @@ fn deserialize_adjacently_tagged_enum(
                     // First key is the tag.
                     _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
                         // Parse the tag.
-                        let __field = try!(_serde::de::MapAccess::next_value(&mut __map));
+                        let __field = _serde::de::MapAccess::next_value(&mut __map)?;
                         // Visit the second key.
                         match #next_relevant_key {
                             // Second key is a duplicate of the tag.
@@ -1671,12 +1671,12 @@ fn deserialize_adjacently_tagged_enum(
                             }
                             // Second key is the content.
                             _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                                let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map,
+                                let __ret = _serde::de::MapAccess::next_value_seed(&mut __map,
                                     __Seed {
                                         field: __field,
                                         marker: _serde::__private::PhantomData,
                                         lifetime: _serde::__private::PhantomData,
-                                    }));
+                                    })?;
                                 // Visit remaining keys, looking for duplicates.
                                 #visit_remaining_keys
                             }
@@ -1687,7 +1687,7 @@ fn deserialize_adjacently_tagged_enum(
                     // First key is the content.
                     _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
                         // Buffer up the content.
-                        let __content = try!(_serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map));
+                        let __content = _serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map)?;
                         // Visit the second key.
                         match #next_relevant_key {
                             // Second key is the tag.
@@ -1717,17 +1717,17 @@ fn deserialize_adjacently_tagged_enum(
                 __A: _serde::de::SeqAccess<#delife>,
             {
                 // Visit the first element - the tag.
-                match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
+                match _serde::de::SeqAccess::next_element(&mut __seq)? {
                     _serde::__private::Some(__field) => {
                         // Visit the second element - the content.
-                        match try!(_serde::de::SeqAccess::next_element_seed(
+                        match _serde::de::SeqAccess::next_element_seed(
                             &mut __seq,
                             __Seed {
                                 field: __field,
                                 marker: _serde::__private::PhantomData,
                                 lifetime: _serde::__private::PhantomData,
                             },
-                        )) {
+                        )? {
                             _serde::__private::Some(__ret) => _serde::__private::Ok(__ret),
                             // There is no second element.
                             _serde::__private::None => {
@@ -1797,7 +1797,7 @@ fn deserialize_untagged_enum_after(
     let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
 
     quote_block! {
-        let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
+        let __content = <_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)?;
         let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
 
         #(
@@ -1830,7 +1830,7 @@ fn deserialize_externally_tagged_variant(
         Style::Unit => {
             let this_value = &params.this_value;
             quote_block! {
-                try!(_serde::de::VariantAccess::unit_variant(__variant));
+                _serde::de::VariantAccess::unit_variant(__variant)?;
                 _serde::__private::Ok(#this_value::#variant_ident)
             }
         }
@@ -1879,7 +1879,7 @@ fn deserialize_internally_tagged_variant(
                 quote!((#default))
             });
             quote_block! {
-                try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
+                _serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))?;
                 _serde::__private::Ok(#this_value::#variant_ident #default)
             }
         }
@@ -1965,7 +1965,7 @@ fn deserialize_externally_tagged_newtype_variant(
     if field.attrs.skip_deserializing() {
         let default = Expr(expr_is_missing(field, cattrs));
         return quote_block! {
-            try!(_serde::de::VariantAccess::unit_variant(__variant));
+            _serde::de::VariantAccess::unit_variant(__variant)?;
             _serde::__private::Ok(#this_value::#variant_ident(#default))
         };
     }
@@ -2540,7 +2540,7 @@ fn deserialize_map(
                     let func =
                         quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
                     quote! {
-                        try!(#func(&mut __map))
+                        #func(&mut __map)?
                     }
                 }
                 Some(path) => {
@@ -2572,14 +2572,14 @@ fn deserialize_map(
             __Field::__other(__name) => {
                 __collect.push(_serde::__private::Some((
                     __name,
-                    try!(_serde::de::MapAccess::next_value(&mut __map)))));
+                    _serde::de::MapAccess::next_value(&mut __map)?)));
             }
         })
     } else if cattrs.deny_unknown_fields() {
         None
     } else {
         Some(quote! {
-            _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
+            _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }
         })
     };
 
@@ -2587,14 +2587,14 @@ fn deserialize_map(
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
+            // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
             _serde::__private::Option::map(
-                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
+                _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
                 |__impossible| match __impossible {});
         }
     } else {
         quote! {
-            while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
+            while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                 match __key {
                     #(#value_arms)*
                     #ignored_arm
@@ -2630,10 +2630,10 @@ fn deserialize_map(
                 Some(path) => quote!(#path),
             };
             quote! {
-                let #name: #field_ty = try!(#func(
+                let #name: #field_ty = #func(
                     _serde::__private::de::FlatMapDeserializer(
                         &mut __collect,
-                        _serde::__private::PhantomData)));
+                        _serde::__private::PhantomData))?;
             }
         });
 
@@ -2780,7 +2780,7 @@ fn deserialize_map_in_place(
             let visit = match field.attrs.deserialize_with() {
                 None => {
                     quote! {
-                        try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
+                        _serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member))?
                     }
                 }
                 Some(path) => {
@@ -2812,7 +2812,7 @@ fn deserialize_map_in_place(
         None
     } else {
         Some(quote! {
-            _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
+            _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }
         })
     };
 
@@ -2821,14 +2821,14 @@ fn deserialize_map_in_place(
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
+            // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
             _serde::__private::Option::map(
-                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
+                _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
                 |__impossible| match __impossible {});
         }
     } else {
         quote! {
-            while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
+            while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                 match __key {
                     #(#value_arms_from)*
                     #ignored_arm
@@ -2925,7 +2925,7 @@ fn wrap_deserialize_with(
                 __D: _serde::Deserializer<#delife>,
             {
                 _serde::__private::Ok(__DeserializeWith {
-                    value: try!(#deserialize_with(__deserializer)),
+                    value: #deserialize_with(__deserializer)?,
                     phantom: _serde::__private::PhantomData,
                     lifetime: _serde::__private::PhantomData,
                 })
@@ -3035,7 +3035,7 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
             let span = field.original.span();
             let func = quote_spanned!(span=> _serde::__private::de::missing_field);
             quote_expr! {
-                try!(#func(#name))
+                #func(#name)?
             }
         }
         Some(_) => {

serde_derive/src/dummy.rs

@@ -1,10 +1,7 @@
-use crate::try;
 use proc_macro2::TokenStream;
 use quote::quote;
 
 pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream {
-    let try_replacement = try::replacement();
-
     let use_serde = match serde_path {
         Some(path) => quote! {
             use #path as _serde;
@@ -20,7 +17,6 @@ pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> Token
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
         const _: () = {
             #use_serde
-            #try_replacement
             #code
         };
     }

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.177")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.179")]
 // Ignored clippy lints
 #![allow(
     // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
@@ -90,7 +90,6 @@ mod dummy;
 mod pretend;
 mod ser;
 mod this;
-mod try;
 
 #[cfg(precompiled)]
 macro_rules! parse_macro_input {

serde_derive/src/ser.rs

@@ -282,7 +282,7 @@ fn serialize_tuple_struct(
         .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
     quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len));
+        let #let_mut __serde_state = _serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len)?;
         #(#serialize_stmts)*
         _serde::ser::SerializeTupleStruct::end(__serde_state)
     }
@@ -304,7 +304,7 @@ fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTra
             let type_name = cattrs.name().serialize_name();
             let func = struct_trait.serialize_field(Span::call_site());
             quote! {
-                try!(#func(&mut __serde_state, #tag, #type_name));
+                #func(&mut __serde_state, #tag, #type_name)?;
             }
         }
         _ => quote! {},
@@ -345,7 +345,7 @@ fn serialize_struct_as_struct(
         );
 
     quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len));
+        let #let_mut __serde_state = _serde::Serializer::serialize_struct(__serializer, #type_name, #len)?;
         #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeStruct::end(__serde_state)
@@ -389,7 +389,7 @@ fn serialize_struct_as_map(
     };
 
     quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len));
+        let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, #len)?;
         #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeMap::end(__serde_state)
@@ -593,10 +593,10 @@ fn serialize_internally_tagged_variant(
     match effective_style(variant) {
         Style::Unit => {
             quote_block! {
-                let mut __struct = try!(_serde::Serializer::serialize_struct(
+                let mut __struct = _serde::Serializer::serialize_struct(
-                    __serializer, #type_name, 1));
+                    __serializer, #type_name, 1)?;
-                try!(_serde::ser::SerializeStruct::serialize_field(
+                _serde::ser::SerializeStruct::serialize_field(
-                    &mut __struct, #tag, #variant_name));
+                    &mut __struct, #tag, #variant_name)?;
                 _serde::ser::SerializeStruct::end(__struct)
             }
         }
@@ -650,10 +650,10 @@ fn serialize_adjacently_tagged_variant(
         match effective_style(variant) {
             Style::Unit => {
                 return quote_block! {
-                    let mut __struct = try!(_serde::Serializer::serialize_struct(
+                    let mut __struct = _serde::Serializer::serialize_struct(
-                        __serializer, #type_name, 1));
+                        __serializer, #type_name, 1)?;
-                    try!(_serde::ser::SerializeStruct::serialize_field(
+                    _serde::ser::SerializeStruct::serialize_field(
-                        &mut __struct, #tag, #variant_name));
+                        &mut __struct, #tag, #variant_name)?;
                     _serde::ser::SerializeStruct::end(__struct)
                 };
             }
@@ -667,12 +667,12 @@ fn serialize_adjacently_tagged_variant(
                 let span = field.original.span();
                 let func = quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field);
                 return quote_block! {
-                    let mut __struct = try!(_serde::Serializer::serialize_struct(
+                    let mut __struct = _serde::Serializer::serialize_struct(
-                        __serializer, #type_name, 2));
+                        __serializer, #type_name, 2)?;
-                    try!(_serde::ser::SerializeStruct::serialize_field(
+                    _serde::ser::SerializeStruct::serialize_field(
-                        &mut __struct, #tag, #variant_name));
+                        &mut __struct, #tag, #variant_name)?;
-                    try!(#func(
+                    #func(
-                        &mut __struct, #content, #field_expr));
+                        &mut __struct, #content, #field_expr)?;
                     _serde::ser::SerializeStruct::end(__struct)
                 };
             }
@@ -732,15 +732,15 @@ fn serialize_adjacently_tagged_variant(
             }
         }
 
-        let mut __struct = try!(_serde::Serializer::serialize_struct(
+        let mut __struct = _serde::Serializer::serialize_struct(
-            __serializer, #type_name, 2));
+            __serializer, #type_name, 2)?;
-        try!(_serde::ser::SerializeStruct::serialize_field(
+        _serde::ser::SerializeStruct::serialize_field(
-            &mut __struct, #tag, #variant_name));
+            &mut __struct, #tag, #variant_name)?;
-        try!(_serde::ser::SerializeStruct::serialize_field(
+        _serde::ser::SerializeStruct::serialize_field(
             &mut __struct, #content, &__AdjacentlyTagged {
                 data: (#(#fields_ident,)*),
                 phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
-            }));
+            })?;
         _serde::ser::SerializeStruct::end(__struct)
     }
 }
@@ -830,21 +830,21 @@ fn serialize_tuple_variant(
             variant_name,
         } => {
             quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
+                let #let_mut __serde_state = _serde::Serializer::serialize_tuple_variant(
                     __serializer,
                     #type_name,
                     #variant_index,
                     #variant_name,
-                    #len));
+                    #len)?;
                 #(#serialize_stmts)*
                 _serde::ser::SerializeTupleVariant::end(__serde_state)
             }
         }
         TupleVariant::Untagged => {
             quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple(
+                let #let_mut __serde_state = _serde::Serializer::serialize_tuple(
                     __serializer,
-                    #len));
+                    #len)?;
                 #(#serialize_stmts)*
                 _serde::ser::SerializeTuple::end(__serde_state)
             }
@@ -907,40 +907,40 @@ fn serialize_struct_variant(
             variant_name,
         } => {
             quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
+                let #let_mut __serde_state = _serde::Serializer::serialize_struct_variant(
                     __serializer,
                     #name,
                     #variant_index,
                     #variant_name,
                     #len,
-                ));
+                )?;
                 #(#serialize_fields)*
                 _serde::ser::SerializeStructVariant::end(__serde_state)
             }
         }
         StructVariant::InternallyTagged { tag, variant_name } => {
             quote_block! {
-                let mut __serde_state = try!(_serde::Serializer::serialize_struct(
+                let mut __serde_state = _serde::Serializer::serialize_struct(
                     __serializer,
                     #name,
                     #len + 1,
-                ));
+                )?;
-                try!(_serde::ser::SerializeStruct::serialize_field(
+                _serde::ser::SerializeStruct::serialize_field(
                     &mut __serde_state,
                     #tag,
                     #variant_name,
-                ));
+                )?;
                 #(#serialize_fields)*
                 _serde::ser::SerializeStruct::end(__serde_state)
             }
         }
         StructVariant::Untagged => {
             quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(
+                let #let_mut __serde_state = _serde::Serializer::serialize_struct(
                     __serializer,
                     #name,
                     #len,
-                ));
+                )?;
                 #(#serialize_fields)*
                 _serde::ser::SerializeStruct::end(__serde_state)
             }
@@ -990,9 +990,9 @@ fn serialize_struct_variant_with_flatten(
                         __S: _serde::Serializer,
                     {
                         let (#(#members,)*) = self.data;
-                        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
+                        let #let_mut __serde_state = _serde::Serializer::serialize_map(
                             __serializer,
-                            _serde::__private::None));
+                            _serde::__private::None)?;
                         #(#serialize_fields)*
                         _serde::ser::SerializeMap::end(__serde_state)
                     }
@@ -1011,23 +1011,23 @@ fn serialize_struct_variant_with_flatten(
         }
         StructVariant::InternallyTagged { tag, variant_name } => {
             quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
+                let #let_mut __serde_state = _serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::__private::None));
+                    _serde::__private::None)?;
-                try!(_serde::ser::SerializeMap::serialize_entry(
+                _serde::ser::SerializeMap::serialize_entry(
                     &mut __serde_state,
                     #tag,
                     #variant_name,
-                ));
+                )?;
                 #(#serialize_fields)*
                 _serde::ser::SerializeMap::end(__serde_state)
             }
         }
         StructVariant::Untagged => {
             quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
+                let #let_mut __serde_state = _serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::__private::None));
+                    _serde::__private::None)?;
                 #(#serialize_fields)*
                 _serde::ser::SerializeMap::end(__serde_state)
             }
@@ -1072,7 +1072,7 @@ fn serialize_tuple_struct_visitor(
             let span = field.original.span();
             let func = tuple_trait.serialize_element(span);
             let ser = quote! {
-                try!(#func(&mut __serde_state, #field_expr));
+                #func(&mut __serde_state, #field_expr)?;
             };
 
             match skip {
@@ -1116,12 +1116,12 @@ fn serialize_struct_visitor(
             let ser = if field.attrs.flatten() {
                 let func = quote_spanned!(span=> _serde::Serialize::serialize);
                 quote! {
-                    try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
+                    #func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state))?;
                 }
             } else {
                 let func = struct_trait.serialize_field(span);
                 quote! {
-                    try!(#func(&mut __serde_state, #key_expr, #field_expr));
+                    #func(&mut __serde_state, #key_expr, #field_expr)?;
                 }
             };
 
@@ -1133,7 +1133,7 @@ fn serialize_struct_visitor(
                             if !#skip {
                                 #ser
                             } else {
-                                try!(#skip_func(&mut __serde_state, #key_expr));
+                                #skip_func(&mut __serde_state, #key_expr)?;
                             }
                         }
                     } else {
@@ -1233,7 +1233,7 @@ fn wrap_serialize_with(
 
 // Serialization of an empty struct results in code like:
 //
-//     let mut __serde_state = try!(serializer.serialize_struct("S", 0));
+//     let mut __serde_state = serializer.serialize_struct("S", 0)?;
 //     _serde::ser::SerializeStruct::end(__serde_state)
 //
 // where we want to omit the `mut` to avoid a warning.

serde_derive/src/try.rs

@@ -1,25 +0,0 @@
-use proc_macro2::{Punct, Spacing, TokenStream};
-use quote::quote;
-
-// None of our generated code requires the `From::from` error conversion
-// performed by the standard library's `try!` macro. With this simplified macro
-// we see a significant improvement in type checking and borrow checking time of
-// the generated code and a slight improvement in binary size.
-pub fn replacement() -> TokenStream {
-    // Cannot pass `$expr` to `quote!` prior to Rust 1.17.0 so interpolate it.
-    let dollar = Punct::new('$', Spacing::Alone);
-
-    quote! {
-        #[allow(unused_macros)]
-        macro_rules! try {
-            (#dollar __expr:expr) => {
-                match #dollar __expr {
-                    _serde::__private::Ok(__val) => __val,
-                    _serde::__private::Err(__err) => {
-                        return _serde::__private::Err(__err);
-                    }
-                }
-            }
-        }
-    }
-}

test_suite/tests/test_annotations.rs

@@ -114,42 +114,6 @@ struct CollectOther {
     extra: HashMap<String, u32>,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct FlattenStructEnumWrapper {
-    #[serde(flatten)]
-    data: FlattenStructEnum,
-    #[serde(flatten)]
-    extra: HashMap<String, String>,
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-enum FlattenStructEnum {
-    InsertInteger { index: u32, value: u32 },
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct FlattenStructTagContentEnumWrapper {
-    outer: u32,
-    #[serde(flatten)]
-    data: FlattenStructTagContentEnumNewtype,
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct FlattenStructTagContentEnumNewtype(pub FlattenStructTagContentEnum);
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case", tag = "type", content = "value")]
-enum FlattenStructTagContentEnum {
-    InsertInteger { index: u32, value: u32 },
-    NewtypeVariant(FlattenStructTagContentEnumNewtypeVariant),
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct FlattenStructTagContentEnumNewtypeVariant {
-    value: u32,
-}
-
 #[test]
 fn test_default_struct() {
     assert_de_tokens(
@@ -1643,149 +1607,6 @@ fn test_collect_other() {
     );
 }
 
-#[test]
-fn test_flatten_struct_enum() {
-    let mut extra = HashMap::new();
-    extra.insert("extra_key".into(), "extra value".into());
-    let change_request = FlattenStructEnumWrapper {
-        data: FlattenStructEnum::InsertInteger {
-            index: 0,
-            value: 42,
-        },
-        extra,
-    };
-    assert_de_tokens(
-        &change_request,
-        &[
-            Token::Map { len: None },
-            Token::Str("insert_integer"),
-            Token::Map { len: None },
-            Token::Str("index"),
-            Token::U32(0),
-            Token::Str("value"),
-            Token::U32(42),
-            Token::MapEnd,
-            Token::Str("extra_key"),
-            Token::Str("extra value"),
-            Token::MapEnd,
-        ],
-    );
-    assert_ser_tokens(
-        &change_request,
-        &[
-            Token::Map { len: None },
-            Token::Str("insert_integer"),
-            Token::Struct {
-                len: 2,
-                name: "insert_integer",
-            },
-            Token::Str("index"),
-            Token::U32(0),
-            Token::Str("value"),
-            Token::U32(42),
-            Token::StructEnd,
-            Token::Str("extra_key"),
-            Token::Str("extra value"),
-            Token::MapEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_flatten_struct_tag_content_enum() {
-    let change_request = FlattenStructTagContentEnumWrapper {
-        outer: 42,
-        data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::InsertInteger {
-            index: 0,
-            value: 42,
-        }),
-    };
-    assert_de_tokens(
-        &change_request,
-        &[
-            Token::Map { len: None },
-            Token::Str("outer"),
-            Token::U32(42),
-            Token::Str("type"),
-            Token::Str("insert_integer"),
-            Token::Str("value"),
-            Token::Map { len: None },
-            Token::Str("index"),
-            Token::U32(0),
-            Token::Str("value"),
-            Token::U32(42),
-            Token::MapEnd,
-            Token::MapEnd,
-        ],
-    );
-    assert_ser_tokens(
-        &change_request,
-        &[
-            Token::Map { len: None },
-            Token::Str("outer"),
-            Token::U32(42),
-            Token::Str("type"),
-            Token::Str("insert_integer"),
-            Token::Str("value"),
-            Token::Struct {
-                len: 2,
-                name: "insert_integer",
-            },
-            Token::Str("index"),
-            Token::U32(0),
-            Token::Str("value"),
-            Token::U32(42),
-            Token::StructEnd,
-            Token::MapEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_flatten_struct_tag_content_enum_newtype() {
-    let change_request = FlattenStructTagContentEnumWrapper {
-        outer: 42,
-        data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::NewtypeVariant(
-            FlattenStructTagContentEnumNewtypeVariant { value: 23 },
-        )),
-    };
-    assert_de_tokens(
-        &change_request,
-        &[
-            Token::Map { len: None },
-            Token::Str("outer"),
-            Token::U32(42),
-            Token::Str("type"),
-            Token::Str("newtype_variant"),
-            Token::Str("value"),
-            Token::Map { len: None },
-            Token::Str("value"),
-            Token::U32(23),
-            Token::MapEnd,
-            Token::MapEnd,
-        ],
-    );
-    assert_ser_tokens(
-        &change_request,
-        &[
-            Token::Map { len: None },
-            Token::Str("outer"),
-            Token::U32(42),
-            Token::Str("type"),
-            Token::Str("newtype_variant"),
-            Token::Str("value"),
-            Token::Struct {
-                len: 1,
-                name: "FlattenStructTagContentEnumNewtypeVariant",
-            },
-            Token::Str("value"),
-            Token::U32(23),
-            Token::StructEnd,
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_unknown_field_in_flatten() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -2142,86 +1963,6 @@ fn test_lifetime_propagation_for_flatten() {
     );
 }
 
-#[test]
-fn test_flatten_enum_newtype() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct S {
-        #[serde(flatten)]
-        flat: E,
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    enum E {
-        Q(HashMap<String, String>),
-    }
-
-    let e = E::Q({
-        let mut map = HashMap::new();
-        map.insert("k".to_owned(), "v".to_owned());
-        map
-    });
-    let s = S { flat: e };
-
-    assert_tokens(
-        &s,
-        &[
-            Token::Map { len: None },
-            Token::Str("Q"),
-            Token::Map { len: Some(1) },
-            Token::Str("k"),
-            Token::Str("v"),
-            Token::MapEnd,
-            Token::MapEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_flatten_internally_tagged() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct S {
-        #[serde(flatten)]
-        x: X,
-        #[serde(flatten)]
-        y: Y,
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "typeX")]
-    enum X {
-        A { a: i32 },
-        B { b: i32 },
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "typeY")]
-    enum Y {
-        C { c: i32 },
-        D { d: i32 },
-    }
-
-    let s = S {
-        x: X::B { b: 1 },
-        y: Y::D { d: 2 },
-    };
-
-    assert_tokens(
-        &s,
-        &[
-            Token::Map { len: None },
-            Token::Str("typeX"),
-            Token::Str("B"),
-            Token::Str("b"),
-            Token::I32(1),
-            Token::Str("typeY"),
-            Token::Str("D"),
-            Token::Str("d"),
-            Token::I32(2),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_externally_tagged_enum_containing_flatten() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2630,35 +2371,6 @@ fn test_partially_untagged_enum_desugared() {
     );
 }
 
-#[test]
-fn test_flatten_untagged_enum() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct Outer {
-        #[serde(flatten)]
-        inner: Inner,
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(untagged)]
-    enum Inner {
-        Variant { a: i32 },
-    }
-
-    let data = Outer {
-        inner: Inner::Variant { a: 0 },
-    };
-
-    assert_tokens(
-        &data,
-        &[
-            Token::Map { len: None },
-            Token::Str("a"),
-            Token::I32(0),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_flatten_option() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2815,48 +2527,6 @@ fn test_internally_tagged_unit_enum_with_unknown_fields() {
     );
 }
 
-#[test]
-fn test_flattened_internally_tagged_unit_enum_with_unknown_fields() {
-    #[derive(Deserialize, PartialEq, Debug)]
-    struct S {
-        #[serde(flatten)]
-        x: X,
-        #[serde(flatten)]
-        y: Y,
-    }
-
-    #[derive(Deserialize, PartialEq, Debug)]
-    #[serde(tag = "typeX")]
-    enum X {
-        A,
-    }
-
-    #[derive(Deserialize, PartialEq, Debug)]
-    #[serde(tag = "typeY")]
-    enum Y {
-        B { c: u32 },
-    }
-
-    let s = S {
-        x: X::A,
-        y: Y::B { c: 0 },
-    };
-
-    assert_de_tokens(
-        &s,
-        &[
-            Token::Map { len: None },
-            Token::Str("typeX"),
-            Token::Str("A"),
-            Token::Str("typeY"),
-            Token::Str("B"),
-            Token::Str("c"),
-            Token::I32(0),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_flatten_any_after_flatten_struct() {
     #[derive(PartialEq, Debug)]
@@ -3149,3 +2819,339 @@ fn test_expecting_message_identifier_enum() {
         r#"invalid type: map, expected something strange..."#,
     );
 }
+
+mod flatten {
+    use super::*;
+
+    mod enum_ {
+        use super::*;
+
+        mod externally_tagged {
+            use super::*;
+            use std::iter::FromIterator;
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            struct Flatten {
+                #[serde(flatten)]
+                data: Enum,
+
+                #[serde(flatten)]
+                extra: HashMap<String, String>,
+            }
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            enum Enum {
+                Newtype(HashMap<String, String>),
+                Tuple(u32, u32),
+                Struct { index: u32, value: u32 },
+            }
+
+            #[test]
+            fn newtype() {
+                assert_tokens(
+                    &Flatten {
+                        data: Enum::Newtype(HashMap::from_iter([("key".into(), "value".into())])),
+                        extra: HashMap::from_iter([("extra_key".into(), "extra value".into())]),
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("Newtype"), // variant
+                        Token::Map { len: Some(1) },
+                        Token::Str("key"),
+                        Token::Str("value"),
+                        Token::MapEnd,
+                        Token::Str("extra_key"),
+                        Token::Str("extra value"),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+
+            // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
+            // Content::Seq case
+            // via FlatMapDeserializer::deserialize_enum
+            #[test]
+            fn tuple() {
+                assert_tokens(
+                    &Flatten {
+                        data: Enum::Tuple(0, 42),
+                        extra: HashMap::from_iter([("extra_key".into(), "extra value".into())]),
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("Tuple"), // variant
+                        Token::Seq { len: Some(2) },
+                        Token::U32(0),
+                        Token::U32(42),
+                        Token::SeqEnd,
+                        Token::Str("extra_key"),
+                        Token::Str("extra value"),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+
+            // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+            // Content::Seq case
+            // via FlatMapDeserializer::deserialize_enum
+            #[test]
+            fn struct_from_seq() {
+                assert_de_tokens(
+                    &Flatten {
+                        data: Enum::Struct {
+                            index: 0,
+                            value: 42,
+                        },
+                        extra: HashMap::from_iter([("extra_key".into(), "extra value".into())]),
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("Struct"), // variant
+                        Token::Seq { len: Some(2) },
+                        Token::U32(0),  // index
+                        Token::U32(42), // value
+                        Token::SeqEnd,
+                        Token::Str("extra_key"),
+                        Token::Str("extra value"),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+
+            // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+            // Content::Map case
+            // via FlatMapDeserializer::deserialize_enum
+            #[test]
+            fn struct_from_map() {
+                assert_tokens(
+                    &Flatten {
+                        data: Enum::Struct {
+                            index: 0,
+                            value: 42,
+                        },
+                        extra: HashMap::from_iter([("extra_key".into(), "extra value".into())]),
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("Struct"), // variant
+                        Token::Struct {
+                            len: 2,
+                            name: "Struct",
+                        },
+                        Token::Str("index"),
+                        Token::U32(0),
+                        Token::Str("value"),
+                        Token::U32(42),
+                        Token::StructEnd,
+                        Token::Str("extra_key"),
+                        Token::Str("extra value"),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+        }
+
+        mod adjacently_tagged {
+            use super::*;
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            struct Flatten {
+                outer: u32,
+
+                #[serde(flatten)]
+                data: NewtypeWrapper,
+            }
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            struct NewtypeWrapper(pub Enum);
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            #[serde(tag = "tag", content = "content")]
+            enum Enum {
+                Newtype(NewtypeVariant),
+                Struct { index: u32, value: u32 },
+            }
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            struct NewtypeVariant {
+                value: u32,
+            }
+
+            #[test]
+            fn struct_() {
+                assert_tokens(
+                    &Flatten {
+                        outer: 42,
+                        data: NewtypeWrapper(Enum::Struct {
+                            index: 0,
+                            value: 42,
+                        }),
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("outer"),
+                        Token::U32(42),
+                        Token::Str("tag"),
+                        Token::Str("Struct"),
+                        Token::Str("content"),
+                        Token::Struct {
+                            len: 2,
+                            name: "Struct",
+                        },
+                        Token::Str("index"),
+                        Token::U32(0),
+                        Token::Str("value"),
+                        Token::U32(42),
+                        Token::StructEnd,
+                        Token::MapEnd,
+                    ],
+                );
+            }
+
+            #[test]
+            fn newtype() {
+                assert_tokens(
+                    &Flatten {
+                        outer: 42,
+                        data: NewtypeWrapper(Enum::Newtype(NewtypeVariant { value: 23 })),
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("outer"),
+                        Token::U32(42),
+                        Token::Str("tag"),
+                        Token::Str("Newtype"),
+                        Token::Str("content"),
+                        Token::Struct {
+                            len: 1,
+                            name: "NewtypeVariant",
+                        },
+                        Token::Str("value"),
+                        Token::U32(23),
+                        Token::StructEnd,
+                        Token::MapEnd,
+                    ],
+                );
+            }
+        }
+
+        mod internally_tagged {
+            use super::*;
+
+            #[test]
+            fn structs() {
+                #[derive(Debug, PartialEq, Serialize, Deserialize)]
+                struct Flatten {
+                    #[serde(flatten)]
+                    x: X,
+                    #[serde(flatten)]
+                    y: Y,
+                }
+
+                #[derive(Debug, PartialEq, Serialize, Deserialize)]
+                #[serde(tag = "typeX")]
+                enum X {
+                    A { a: i32 },
+                    B { b: i32 },
+                }
+
+                #[derive(Debug, PartialEq, Serialize, Deserialize)]
+                #[serde(tag = "typeY")]
+                enum Y {
+                    C { c: i32 },
+                    D { d: i32 },
+                }
+
+                assert_tokens(
+                    &Flatten {
+                        x: X::B { b: 1 },
+                        y: Y::D { d: 2 },
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("typeX"),
+                        Token::Str("B"),
+                        Token::Str("b"),
+                        Token::I32(1),
+                        Token::Str("typeY"),
+                        Token::Str("D"),
+                        Token::Str("d"),
+                        Token::I32(2),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+
+            #[test]
+            fn unit_enum_with_unknown_fields() {
+                #[derive(Debug, PartialEq, Deserialize)]
+                struct Flatten {
+                    #[serde(flatten)]
+                    x: X,
+                    #[serde(flatten)]
+                    y: Y,
+                }
+
+                #[derive(Debug, PartialEq, Deserialize)]
+                #[serde(tag = "typeX")]
+                enum X {
+                    A,
+                }
+
+                #[derive(Debug, PartialEq, Deserialize)]
+                #[serde(tag = "typeY")]
+                enum Y {
+                    B { c: u32 },
+                }
+
+                assert_de_tokens(
+                    &Flatten {
+                        x: X::A,
+                        y: Y::B { c: 0 },
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("typeX"),
+                        Token::Str("A"),
+                        Token::Str("typeY"),
+                        Token::Str("B"),
+                        Token::Str("c"),
+                        Token::I32(0),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+        }
+
+        mod untagged {
+            use super::*;
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            struct Flatten {
+                #[serde(flatten)]
+                data: Enum,
+            }
+
+            #[derive(Debug, PartialEq, Serialize, Deserialize)]
+            #[serde(untagged)]
+            enum Enum {
+                Struct { a: i32 },
+            }
+
+            #[test]
+            fn struct_() {
+                assert_tokens(
+                    &Flatten {
+                        data: Enum::Struct { a: 0 },
+                    },
+                    &[
+                        Token::Map { len: None },
+                        Token::Str("a"),
+                        Token::I32(0),
+                        Token::MapEnd,
+                    ],
+                );
+            }
+        }
+    }
+}

test_suite/tests/test_macros.rs

@@ -1429,6 +1429,9 @@ fn test_enum_in_internally_tagged_enum() {
         ],
     );
 
+    // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
+    // Content::Seq case
+    // via ContentDeserializer::deserialize_enum
     assert_tokens(
         &Outer::Inner(Inner::Tuple(1, 1)),
         &[
@@ -1447,6 +1450,9 @@ fn test_enum_in_internally_tagged_enum() {
         ],
     );
 
+    // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+    // Content::Map case
+    // via ContentDeserializer::deserialize_enum
     assert_tokens(
         &Outer::Inner(Inner::Struct { f: 1 }),
         &[
@@ -1464,6 +1470,23 @@ fn test_enum_in_internally_tagged_enum() {
             Token::MapEnd,
         ],
     );
+
+    // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+    // Content::Seq case
+    // via ContentDeserializer::deserialize_enum
+    assert_de_tokens(
+        &Outer::Inner(Inner::Struct { f: 1 }),
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("type"),
+            Token::Str("Inner"),
+            Token::Str("Struct"),
+            Token::Seq { len: Some(1) },
+            Token::U8(1), // f
+            Token::SeqEnd,
+            Token::MapEnd,
+        ],
+    );
 }
 
 #[test]