Release 1.0.208

Support (de-)serializing flattened unit struct

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.206"
+version = "1.0.208"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
@@ -37,7 +37,7 @@ rustdoc-args = ["--generate-link-to-definition"]
 # is compatible with exactly one serde release because the generated code
 # involves nonpublic APIs which are not bound by semver.
 [target.'cfg(any())'.dependencies]
-serde_derive = { version = "=1.0.206", path = "../serde_derive" }
+serde_derive = { version = "=1.0.208", path = "../serde_derive" }
 
 
 ### FEATURES #################################################################

serde/src/lib.rs

@@ -95,7 +95,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.206")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.208")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Show which crate feature enables conditionally compiled APIs in documentation.

serde/src/private/de.rs

@@ -2710,6 +2710,17 @@ where
         visitor.visit_unit()
     }
 
+    fn deserialize_unit_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
     fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -2734,7 +2745,6 @@ where
         deserialize_string()
         deserialize_bytes()
         deserialize_byte_buf()
-        deserialize_unit_struct(&'static str)
         deserialize_seq()
         deserialize_tuple(usize)
         deserialize_tuple_struct(&'static str, usize)

serde/src/private/ser.rs

@@ -51,8 +51,6 @@ enum Unsupported {
     String,
     ByteArray,
     Optional,
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    UnitStruct,
     Sequence,
     Tuple,
     TupleStruct,
@@ -69,8 +67,6 @@ impl Display for Unsupported {
             Unsupported::String => formatter.write_str("a string"),
             Unsupported::ByteArray => formatter.write_str("a byte array"),
             Unsupported::Optional => formatter.write_str("an optional"),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Unsupported::UnitStruct => formatter.write_str("unit struct"),
             Unsupported::Sequence => formatter.write_str("a sequence"),
             Unsupported::Tuple => formatter.write_str("a tuple"),
             Unsupported::TupleStruct => formatter.write_str("a tuple struct"),
@@ -1092,7 +1088,7 @@ where
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::UnitStruct))
+        Ok(())
     }
 
     fn serialize_unit_variant(

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.206"
+version = "1.0.208"
 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

@@ -281,21 +281,11 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
     } else if let attr::Identifier::No = cont.attrs.identifier() {
         match &cont.data {
             Data::Enum(variants) => deserialize_enum(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, fields) => deserialize_struct(
-                params,
-                fields,
-                &cont.attrs,
-                cont.attrs.has_flatten(),
-                StructForm::Struct,
-            ),
+            Data::Struct(Style::Struct, fields) => {
+                deserialize_struct(params, fields, &cont.attrs, StructForm::Struct)
+            }
             Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-                deserialize_tuple(
-                    params,
-                    fields,
-                    &cont.attrs,
-                    cont.attrs.has_flatten(),
-                    TupleForm::Tuple,
-                )
+                deserialize_tuple(params, fields, &cont.attrs, TupleForm::Tuple)
             }
             Data::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
         }
@@ -469,11 +459,10 @@ fn deserialize_tuple(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
-    has_flatten: bool,
     form: TupleForm,
 ) -> Fragment {
     assert!(
-        !has_flatten,
+        !has_flatten(fields),
         "tuples and tuple variants cannot have flatten fields"
     );
 
@@ -594,7 +583,7 @@ fn deserialize_tuple_in_place(
     cattrs: &attr::Container,
 ) -> Fragment {
     assert!(
-        !cattrs.has_flatten(),
+        !has_flatten(fields),
         "tuples and tuple variants cannot have flatten fields"
     );
 
@@ -927,7 +916,6 @@ fn deserialize_struct(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
-    has_flatten: bool,
     form: StructForm,
 ) -> Fragment {
     let this_type = &params.this_type;
@@ -976,6 +964,8 @@ fn deserialize_struct(
             )
         })
         .collect();
+
+    let has_flatten = has_flatten(fields);
     let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs, has_flatten);
 
     // untagged struct variants do not get a visit_seq method. The same applies to
@@ -1115,7 +1105,7 @@ fn deserialize_struct_in_place(
 ) -> Option<Fragment> {
     // for now we do not support in_place deserialization for structs that
     // are represented as map.
-    if cattrs.has_flatten() {
+    if has_flatten(fields) {
         return None;
     }
 
@@ -1831,14 +1821,12 @@ fn deserialize_externally_tagged_variant(
             params,
             &variant.fields,
             cattrs,
-            variant.attrs.has_flatten(),
             TupleForm::ExternallyTagged(variant_ident),
         ),
         Style::Struct => deserialize_struct(
             params,
             &variant.fields,
             cattrs,
-            variant.attrs.has_flatten(),
             StructForm::ExternallyTagged(variant_ident),
         ),
     }
@@ -1882,7 +1870,6 @@ fn deserialize_internally_tagged_variant(
             params,
             &variant.fields,
             cattrs,
-            variant.attrs.has_flatten(),
             StructForm::InternallyTagged(variant_ident, deserializer),
         ),
         Style::Tuple => unreachable!("checked in serde_derive_internals"),
@@ -1933,14 +1920,12 @@ fn deserialize_untagged_variant(
             params,
             &variant.fields,
             cattrs,
-            variant.attrs.has_flatten(),
             TupleForm::Untagged(variant_ident, deserializer),
         ),
         Style::Struct => deserialize_struct(
             params,
             &variant.fields,
             cattrs,
-            variant.attrs.has_flatten(),
             StructForm::Untagged(variant_ident, deserializer),
         ),
     }
@@ -2707,7 +2692,7 @@ fn deserialize_map_in_place(
     cattrs: &attr::Container,
 ) -> Fragment {
     assert!(
-        !cattrs.has_flatten(),
+        !has_flatten(fields),
         "inplace deserialization of maps does not support flatten fields"
     );
 
@@ -3042,6 +3027,14 @@ fn effective_style(variant: &Variant) -> Style {
     }
 }
 
+/// True if there is any field with a `#[serde(flatten)]` attribute, other than
+/// fields which are skipped.
+fn has_flatten(fields: &[Field]) -> bool {
+    fields
+        .iter()
+        .any(|field| field.attrs.flatten() && !field.attrs.skip_deserializing())
+}
+
 struct DeImplGenerics<'a>(&'a Parameters);
 #[cfg(feature = "deserialize_in_place")]
 struct InPlaceImplGenerics<'a>(&'a Parameters);

serde_derive/src/internals/ast.rs

@@ -63,7 +63,7 @@ impl<'a> Container<'a> {
         item: &'a syn::DeriveInput,
         derive: Derive,
     ) -> Option<Container<'a>> {
-        let mut attrs = attr::Container::from_ast(cx, item);
+        let attrs = attr::Container::from_ast(cx, item);
 
         let mut data = match &item.data {
             syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants, attrs.default())),
@@ -77,16 +77,11 @@ impl<'a> Container<'a> {
             }
         };
 
-        let mut has_flatten = false;
         match &mut data {
             Data::Enum(variants) => {
                 for variant in variants {
                     variant.attrs.rename_by_rules(attrs.rename_all_rules());
                     for field in &mut variant.fields {
-                        if field.attrs.flatten() {
-                            has_flatten = true;
-                            variant.attrs.mark_has_flatten();
-                        }
                         field.attrs.rename_by_rules(
                             variant
                                 .attrs
@@ -98,18 +93,11 @@ impl<'a> Container<'a> {
             }
             Data::Struct(_, fields) => {
                 for field in fields {
-                    if field.attrs.flatten() {
-                        has_flatten = true;
-                    }
                     field.attrs.rename_by_rules(attrs.rename_all_rules());
                 }
             }
         }
 
-        if has_flatten {
-            attrs.mark_has_flatten();
-        }
-
         let mut item = Container {
             ident: item.ident.clone(),
             attrs,

serde_derive/src/internals/attr.rs

@@ -216,23 +216,6 @@ pub struct Container {
     type_into: Option<syn::Type>,
     remote: Option<syn::Path>,
     identifier: Identifier,
-    /// True if container is a struct and has a field with `#[serde(flatten)]`,
-    /// or is an enum with a struct variant which has a field with
-    /// `#[serde(flatten)]`.
-    ///
-    /// ```ignore
-    /// struct Container {
-    ///     #[serde(flatten)]
-    ///     some_field: (),
-    /// }
-    /// enum Container {
-    ///     Variant {
-    ///         #[serde(flatten)]
-    ///         some_field: (),
-    ///     },
-    /// }
-    /// ```
-    has_flatten: bool,
     serde_path: Option<syn::Path>,
     is_packed: bool,
     /// Error message generated when type can't be deserialized
@@ -603,7 +586,6 @@ impl Container {
             type_into: type_into.get(),
             remote: remote.get(),
             identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
-            has_flatten: false,
             serde_path: serde_path.get(),
             is_packed,
             expecting: expecting.get(),
@@ -671,14 +653,6 @@ impl Container {
         self.identifier
     }
 
-    pub fn has_flatten(&self) -> bool {
-        self.has_flatten
-    }
-
-    pub fn mark_has_flatten(&mut self) {
-        self.has_flatten = true;
-    }
-
     pub fn custom_serde_path(&self) -> Option<&syn::Path> {
         self.serde_path.as_ref()
     }
@@ -810,18 +784,6 @@ pub struct Variant {
     rename_all_rules: RenameAllRules,
     ser_bound: Option<Vec<syn::WherePredicate>>,
     de_bound: Option<Vec<syn::WherePredicate>>,
-    /// True if variant is a struct variant which contains a field with
-    /// `#[serde(flatten)]`.
-    ///
-    /// ```ignore
-    /// enum Enum {
-    ///     Variant {
-    ///         #[serde(flatten)]
-    ///         some_field: (),
-    ///     },
-    /// }
-    /// ```
-    has_flatten: bool,
     skip_deserializing: bool,
     skip_serializing: bool,
     other: bool,
@@ -991,7 +953,6 @@ impl Variant {
             },
             ser_bound: ser_bound.get(),
             de_bound: de_bound.get(),
-            has_flatten: false,
             skip_deserializing: skip_deserializing.get(),
             skip_serializing: skip_serializing.get(),
             other: other.get(),
@@ -1034,14 +995,6 @@ impl Variant {
         self.de_bound.as_ref().map(|vec| &vec[..])
     }
 
-    pub fn has_flatten(&self) -> bool {
-        self.has_flatten
-    }
-
-    pub fn mark_has_flatten(&mut self) {
-        self.has_flatten = true;
-    }
-
     pub fn skip_deserializing(&self) -> bool {
         self.skip_deserializing
     }

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.206")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.208")]
 #![cfg_attr(not(check_cfg), allow(unexpected_cfgs))]
 // Ignored clippy lints
 #![allow(

serde_derive/src/ser.rs

@@ -289,9 +289,18 @@ fn serialize_tuple_struct(
 }
 
 fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    assert!(fields.len() as u64 <= u64::from(u32::MAX));
+    assert!(
+        fields.len() as u64 <= u64::from(u32::MAX),
+        "too many fields in {}: {}, maximum supported count is {}",
+        cattrs.name().serialize_name(),
+        fields.len(),
+        u32::MAX,
+    );
 
-    if cattrs.has_flatten() {
+    let has_non_skipped_flatten = fields
+        .iter()
+        .any(|field| field.attrs.flatten() && !field.attrs.skip_serializing());
+    if has_non_skipped_flatten {
         serialize_struct_as_map(params, fields, cattrs)
     } else {
         serialize_struct_as_struct(params, fields, cattrs)
@@ -370,26 +379,8 @@ fn serialize_struct_as_map(
 
     let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
 
-    let len = if cattrs.has_flatten() {
-        quote!(_serde::__private::None)
-    } else {
-        let len = serialized_fields
-            .map(|field| match field.attrs.skip_serializing_if() {
-                None => quote!(1),
-                Some(path) => {
-                    let field_expr = get_member(params, field, &field.member);
-                    quote!(if #path(#field_expr) { 0 } else { 1 })
-                }
-            })
-            .fold(
-                quote!(#tag_field_exists as usize),
-                |sum, expr| quote!(#sum + #expr),
-            );
-        quote!(_serde::__private::Some(#len))
-    };
-
     quote_block! {
-        let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, #len)?;
+        let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, _serde::__private::None)?;
         #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeMap::end(__serde_state)

test_suite/tests/test_annotations.rs

@@ -1815,6 +1815,32 @@ fn test_flatten_unit() {
     );
 }
 
+#[test]
+fn test_flatten_unit_struct() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Response<T> {
+        #[serde(flatten)]
+        data: T,
+        status: usize,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Unit;
+
+    assert_tokens(
+        &Response {
+            data: Unit,
+            status: 0,
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("status"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_flatten_unsupported_type() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]

test_suite/tests/test_gen.rs

@@ -547,6 +547,12 @@ fn test_gen() {
     }
     assert::<FlattenWith>();
 
+    #[derive(Serialize, Deserialize)]
+    pub struct Flatten<T> {
+        #[serde(flatten)]
+        t: T,
+    }
+
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
     pub struct FlattenDenyUnknown<T> {
@@ -554,6 +560,19 @@ fn test_gen() {
         t: T,
     }
 
+    #[derive(Serialize, Deserialize)]
+    pub struct SkipDeserializing<T> {
+        #[serde(skip_deserializing)]
+        flat: T,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    pub struct SkipDeserializingDenyUnknown<T> {
+        #[serde(skip_deserializing)]
+        flat: T,
+    }
+
     #[derive(Serialize, Deserialize)]
     pub struct StaticStrStruct<'a> {
         a: &'a str,
@@ -720,14 +739,11 @@ fn test_gen() {
         flat: StdOption<T>,
     }
 
-    #[allow(clippy::collection_is_never_read)] // FIXME
-    const _: () = {
-        #[derive(Serialize, Deserialize)]
-        pub struct FlattenSkipDeserializing<T> {
-            #[serde(flatten, skip_deserializing)]
-            flat: T,
-        }
-    };
+    #[derive(Serialize, Deserialize)]
+    pub struct FlattenSkipDeserializing<T> {
+        #[serde(flatten, skip_deserializing)]
+        flat: T,
+    }
 
     #[derive(Serialize, Deserialize)]
     #[serde(untagged)]