Release 1.0.206

warning: you should put bare URLs between `<`/`>` or make a proper Markdown link
        --> test_suite/tests/test_annotations.rs:2383:25
         |
    2383 | /// Regression test for https://github.com/serde-rs/serde/issues/1904
         |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `<https://github.com/serde-rs/serde/issues/1904>`
         |
         = 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: to override `-W clippy::pedantic` add `#[allow(clippy::doc_markdown)]`

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.204"
+version = "1.0.206"
 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.204", path = "../serde_derive" }
+serde_derive = { version = "=1.0.206", 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.204")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.206")]
 // 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/ser.rs

@@ -1125,8 +1125,7 @@ where
     where
         T: ?Sized + Serialize,
     {
-        tri!(self.0.serialize_key(variant));
-        self.0.serialize_value(value)
+        self.0.serialize_entry(variant, value)
     }
 
     fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.206"
 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,11 +281,21 @@ 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, StructForm::Struct)
-            }
+            Data::Struct(Style::Struct, fields) => deserialize_struct(
+                params,
+                fields,
+                &cont.attrs,
+                cont.attrs.has_flatten(),
+                StructForm::Struct,
+            ),
             Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-                deserialize_tuple(params, fields, &cont.attrs, TupleForm::Tuple)
+                deserialize_tuple(
+                    params,
+                    fields,
+                    &cont.attrs,
+                    cont.attrs.has_flatten(),
+                    TupleForm::Tuple,
+                )
             }
             Data::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
         }
@@ -459,9 +469,13 @@ fn deserialize_tuple(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
+    has_flatten: bool,
     form: TupleForm,
 ) -> Fragment {
-    assert!(!cattrs.has_flatten());
+    assert!(
+        !has_flatten,
+        "tuples and tuple variants cannot have flatten fields"
+    );
 
     let field_count = fields
         .iter()
@@ -579,7 +593,10 @@ fn deserialize_tuple_in_place(
     fields: &[Field],
     cattrs: &attr::Container,
 ) -> Fragment {
-    assert!(!cattrs.has_flatten());
+    assert!(
+        !cattrs.has_flatten(),
+        "tuples and tuple variants cannot have flatten fields"
+    );
 
     let field_count = fields
         .iter()
@@ -910,6 +927,7 @@ fn deserialize_struct(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
+    has_flatten: bool,
     form: StructForm,
 ) -> Fragment {
     let this_type = &params.this_type;
@@ -958,13 +976,13 @@ fn deserialize_struct(
             )
         })
         .collect();
-    let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs);
+    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
     // structs that only have a map representation.
     let visit_seq = match form {
         StructForm::Untagged(..) => None,
-        _ if cattrs.has_flatten() => None,
+        _ if has_flatten => None,
         _ => {
             let mut_seq = if field_names_idents.is_empty() {
                 quote!(_)
@@ -987,10 +1005,16 @@ fn deserialize_struct(
             })
         }
     };
-    let visit_map = Stmts(deserialize_map(&type_path, params, fields, cattrs));
+    let visit_map = Stmts(deserialize_map(
+        &type_path,
+        params,
+        fields,
+        cattrs,
+        has_flatten,
+    ));
 
     let visitor_seed = match form {
-        StructForm::ExternallyTagged(..) if cattrs.has_flatten() => Some(quote! {
+        StructForm::ExternallyTagged(..) if has_flatten => Some(quote! {
             impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
                 type Value = #this_type #ty_generics;
 
@@ -1005,7 +1029,7 @@ fn deserialize_struct(
         _ => None,
     };
 
-    let fields_stmt = if cattrs.has_flatten() {
+    let fields_stmt = if has_flatten {
         None
     } else {
         let field_names = field_names_idents
@@ -1025,7 +1049,7 @@ fn deserialize_struct(
         }
     };
     let dispatch = match form {
-        StructForm::Struct if cattrs.has_flatten() => quote! {
+        StructForm::Struct if has_flatten => quote! {
             _serde::Deserializer::deserialize_map(__deserializer, #visitor_expr)
         },
         StructForm::Struct => {
@@ -1034,7 +1058,7 @@ fn deserialize_struct(
                 _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
             }
         }
-        StructForm::ExternallyTagged(_) if cattrs.has_flatten() => quote! {
+        StructForm::ExternallyTagged(_) if has_flatten => quote! {
             _serde::de::VariantAccess::newtype_variant_seed(__variant, #visitor_expr)
         },
         StructForm::ExternallyTagged(_) => quote! {
@@ -1116,7 +1140,7 @@ fn deserialize_struct_in_place(
         })
         .collect();
 
-    let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs);
+    let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs, false);
 
     let mut_seq = if field_names_idents.is_empty() {
         quote!(_)
@@ -1210,10 +1234,7 @@ fn deserialize_homogeneous_enum(
     }
 }
 
-fn prepare_enum_variant_enum(
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> (TokenStream, Stmts) {
+fn prepare_enum_variant_enum(variants: &[Variant]) -> (TokenStream, Stmts) {
     let mut deserialized_variants = variants
         .iter()
         .enumerate()
@@ -1247,7 +1268,7 @@ fn prepare_enum_variant_enum(
 
     let variant_visitor = Stmts(deserialize_generated_identifier(
         &variant_names_idents,
-        cattrs,
+        false, // variant identifiers do not depend on the presence of flatten fields
         true,
         None,
         fallthrough,
@@ -1270,7 +1291,7 @@ fn deserialize_externally_tagged_enum(
     let expecting = format!("enum {}", params.type_name());
     let expecting = cattrs.expecting().unwrap_or(&expecting);
 
-    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants);
 
     // Match arms to extract a variant from a string
     let variant_arms = variants
@@ -1355,7 +1376,7 @@ fn deserialize_internally_tagged_enum(
     cattrs: &attr::Container,
     tag: &str,
 ) -> Fragment {
-    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants);
 
     // Match arms to extract a variant from a string
     let variant_arms = variants
@@ -1409,7 +1430,7 @@ fn deserialize_adjacently_tagged_enum(
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
 
-    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants);
 
     let variant_arms: &Vec<_> = &variants
         .iter()
@@ -1810,12 +1831,14 @@ 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),
         ),
     }
@@ -1859,6 +1882,7 @@ 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"),
@@ -1909,12 +1933,14 @@ 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),
         ),
     }
@@ -1985,7 +2011,7 @@ fn deserialize_untagged_newtype_variant(
 
 fn deserialize_generated_identifier(
     fields: &[(&str, Ident, &BTreeSet<String>)],
-    cattrs: &attr::Container,
+    has_flatten: bool,
     is_variant: bool,
     ignore_variant: Option<TokenStream>,
     fallthrough: Option<TokenStream>,
@@ -1999,11 +2025,11 @@ fn deserialize_generated_identifier(
         is_variant,
         fallthrough,
         None,
-        !is_variant && cattrs.has_flatten(),
+        !is_variant && has_flatten,
         None,
     ));
 
-    let lifetime = if !is_variant && cattrs.has_flatten() {
+    let lifetime = if !is_variant && has_flatten {
         Some(quote!(<'de>))
     } else {
         None
@@ -2043,8 +2069,9 @@ fn deserialize_generated_identifier(
 fn deserialize_field_identifier(
     fields: &[(&str, Ident, &BTreeSet<String>)],
     cattrs: &attr::Container,
+    has_flatten: bool,
 ) -> Stmts {
-    let (ignore_variant, fallthrough) = if cattrs.has_flatten() {
+    let (ignore_variant, fallthrough) = if has_flatten {
         let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
         let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value)));
         (Some(ignore_variant), Some(fallthrough))
@@ -2058,7 +2085,7 @@ fn deserialize_field_identifier(
 
     Stmts(deserialize_generated_identifier(
         fields,
-        cattrs,
+        has_flatten,
         false,
         ignore_variant,
         fallthrough,
@@ -2460,6 +2487,7 @@ fn deserialize_map(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
+    has_flatten: bool,
 ) -> Fragment {
     // Create the field names for the fields.
     let fields_names: Vec<_> = fields
@@ -2480,7 +2508,7 @@ fn deserialize_map(
         });
 
     // Collect contents for flatten fields into a buffer
-    let let_collect = if cattrs.has_flatten() {
+    let let_collect = if has_flatten {
         Some(quote! {
             let mut __collect = _serde::__private::Vec::<_serde::__private::Option<(
                 _serde::__private::de::Content,
@@ -2532,7 +2560,7 @@ fn deserialize_map(
         });
 
     // Visit ignored values to consume them
-    let ignored_arm = if cattrs.has_flatten() {
+    let ignored_arm = if has_flatten {
         Some(quote! {
             __Field::__other(__name) => {
                 __collect.push(_serde::__private::Some((
@@ -2602,7 +2630,7 @@ fn deserialize_map(
             }
         });
 
-    let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
+    let collected_deny_unknown_fields = if has_flatten && cattrs.deny_unknown_fields() {
         Some(quote! {
             if let _serde::__private::Some(_serde::__private::Some((__key, _))) =
                 __collect.into_iter().filter(_serde::__private::Option::is_some).next()
@@ -2678,7 +2706,10 @@ fn deserialize_map_in_place(
     fields: &[Field],
     cattrs: &attr::Container,
 ) -> Fragment {
-    assert!(!cattrs.has_flatten());
+    assert!(
+        !cattrs.has_flatten(),
+        "inplace deserialization of maps does not support flatten fields"
+    );
 
     // Create the field names for the fields.
     let fields_names: Vec<_> = fields

serde_derive/src/internals/ast.rs

@@ -85,6 +85,7 @@ impl<'a> Container<'a> {
                     for field in &mut variant.fields {
                         if field.attrs.flatten() {
                             has_flatten = true;
+                            variant.attrs.mark_has_flatten();
                         }
                         field.attrs.rename_by_rules(
                             variant

serde_derive/src/internals/attr.rs

@@ -216,6 +216,22 @@ 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,
@@ -794,6 +810,18 @@ 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,
@@ -963,6 +991,7 @@ 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(),
@@ -1005,6 +1034,14 @@ 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.204")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.206")]
 #![cfg_attr(not(check_cfg), allow(unexpected_cfgs))]
 // Ignored clippy lints
 #![allow(

test_suite/no_std/src/main.rs

@@ -23,21 +23,21 @@ fn panic(_info: &core::panic::PanicInfo) -> ! {
 use serde_derive::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
-struct Unit;
+pub struct Unit;
 
 #[derive(Serialize, Deserialize)]
-struct Newtype(u8);
+pub struct Newtype(u8);
 
 #[derive(Serialize, Deserialize)]
-struct Tuple(u8, u8);
+pub struct Tuple(u8, u8);
 
 #[derive(Serialize, Deserialize)]
-struct Struct {
+pub struct Struct {
     f: u8,
 }
 
 #[derive(Serialize, Deserialize)]
-enum Enum {
+pub enum Enum {
     Unit,
     Newtype(u8),
     Tuple(u8, u8),

test_suite/tests/regression/issue1904.rs

@@ -0,0 +1,66 @@
+#![allow(dead_code)] // we do not read enum fields
+
+use serde_derive::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Nested;
+
+#[derive(Deserialize)]
+pub enum ExternallyTagged1 {
+    Tuple(f64, String),
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+    },
+}
+
+#[derive(Deserialize)]
+pub enum ExternallyTagged2 {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+    },
+    Tuple(f64, String),
+}
+
+// Internally tagged enums cannot contain tuple variants so not tested here
+
+#[derive(Deserialize)]
+#[serde(tag = "tag", content = "content")]
+pub enum AdjacentlyTagged1 {
+    Tuple(f64, String),
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "tag", content = "content")]
+pub enum AdjacentlyTagged2 {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+    },
+    Tuple(f64, String),
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum Untagged1 {
+    Tuple(f64, String),
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum Untagged2 {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+    },
+    Tuple(f64, String),
+}

test_suite/tests/regression/issue2565.rs

@@ -0,0 +1,41 @@
+use serde_derive::{Serialize, Deserialize};
+use serde_test::{assert_tokens, Token};
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+enum Enum {
+    Simple {
+        a: i32,
+    },
+    Flatten {
+        #[serde(flatten)]
+        flatten: (),
+        a: i32,
+    },
+}
+
+#[test]
+fn simple_variant() {
+    assert_tokens(
+        &Enum::Simple { a: 42 },
+        &[
+            Token::StructVariant { name: "Enum", variant: "Simple", len: 1 },
+            Token::Str("a"),
+            Token::I32(42),
+            Token::StructVariantEnd,
+        ]
+    );
+}
+
+#[test]
+fn flatten_variant() {
+    assert_tokens(
+        &Enum::Flatten { flatten: (), a: 42 },
+        &[
+            Token::NewtypeVariant { name: "Enum", variant: "Flatten" },
+            Token::Map { len: None },
+            Token::Str("a"),
+            Token::I32(42),
+            Token::MapEnd,
+        ]
+    );
+}

test_suite/tests/regression/issue2792.rs

@@ -0,0 +1,18 @@
+#![allow(dead_code)] // we do not read enum fields
+
+use serde_derive::Deserialize;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub enum A {
+    B {
+        c: String,
+    },
+    D {
+        #[serde(flatten)]
+        e: E,
+    },
+}
+
+#[derive(Deserialize)]
+pub struct E {}

test_suite/tests/test_annotations.rs

@@ -2380,6 +2380,56 @@ fn test_partially_untagged_enum_desugared() {
     );
 }
 
+// Regression test for https://github.com/serde-rs/serde/issues/1904
+#[test]
+fn test_enum_tuple_and_struct_with_flatten() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    enum Outer {
+        Tuple(f64, i32),
+        Flatten {
+            #[serde(flatten)]
+            nested: Nested,
+        },
+    }
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct Nested {
+        a: i32,
+        b: i32,
+    }
+
+    assert_tokens(
+        &Outer::Tuple(1.2, 3),
+        &[
+            Token::TupleVariant {
+                name: "Outer",
+                variant: "Tuple",
+                len: 2,
+            },
+            Token::F64(1.2),
+            Token::I32(3),
+            Token::TupleVariantEnd,
+        ],
+    );
+    assert_tokens(
+        &Outer::Flatten {
+            nested: Nested { a: 1, b: 2 },
+        },
+        &[
+            Token::NewtypeVariant {
+                name: "Outer",
+                variant: "Flatten",
+            },
+            Token::Map { len: None },
+            Token::Str("a"),
+            Token::I32(1),
+            Token::Str("b"),
+            Token::I32(2),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_partially_untagged_internally_tagged_enum() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]

test_suite/tests/test_borrow.rs

@@ -162,7 +162,7 @@ fn test_cow() {
 #[test]
 fn test_lifetimes() {
     #[derive(Deserialize)]
-    struct Cows<'a, 'b> {
+    pub struct Cows<'a, 'b> {
         _copied: Cow<'a, str>,
 
         #[serde(borrow)]
@@ -178,7 +178,7 @@ fn test_lifetimes() {
     }
 
     #[derive(Deserialize)]
-    struct Wrap<'a, 'b> {
+    pub struct Wrap<'a, 'b> {
         #[serde(borrow = "'b")]
         _cows: Cows<'a, 'b>,
     }

test_suite/tests/test_de.rs

@@ -93,7 +93,7 @@ struct StructSkipDefault {
 
 #[derive(PartialEq, Debug, Deserialize)]
 #[serde(default)]
-struct StructSkipDefaultGeneric<T> {
+pub struct StructSkipDefaultGeneric<T> {
     #[serde(skip_deserializing)]
     t: T,
 }

test_suite/tests/test_gen.rs

@@ -4,6 +4,7 @@
 
 #![deny(warnings)]
 #![allow(
+    confusable_idents,
     unknown_lints,
     mixed_script_confusables,
     clippy::derive_partial_eq_without_eq,
@@ -19,6 +20,7 @@
     clippy::trivially_copy_pass_by_ref,
     clippy::type_repetition_in_bounds
 )]
+#![deny(clippy::collection_is_never_read)]
 
 use serde::de::{Deserialize, DeserializeOwned, Deserializer};
 use serde::ser::{Serialize, Serializer};
@@ -287,60 +289,60 @@ fn test_gen() {
     assert::<EmptyEnumVariant>();
 
     #[derive(Serialize, Deserialize)]
-    struct NonAsciiIdents {
+    pub struct NonAsciiIdents {
         σ: f64,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct EmptyBraced {}
+    pub struct EmptyBraced {}
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct EmptyBracedDenyUnknown {}
+    pub struct EmptyBracedDenyUnknown {}
 
     #[derive(Serialize, Deserialize)]
-    struct BracedSkipAll {
+    pub struct BracedSkipAll {
         #[serde(skip_deserializing)]
         f: u8,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct BracedSkipAllDenyUnknown {
+    pub struct BracedSkipAllDenyUnknown {
         #[serde(skip_deserializing)]
         f: u8,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct EmptyTuple();
+    pub struct EmptyTuple();
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct EmptyTupleDenyUnknown();
+    pub struct EmptyTupleDenyUnknown();
 
     #[derive(Serialize, Deserialize)]
-    struct TupleSkipAll(#[serde(skip_deserializing)] u8);
+    pub struct TupleSkipAll(#[serde(skip_deserializing)] u8);
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
+    pub struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
 
     #[derive(Serialize, Deserialize)]
-    enum EmptyEnum {}
+    pub enum EmptyEnum {}
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    enum EmptyEnumDenyUnknown {}
+    pub enum EmptyEnumDenyUnknown {}
 
     #[derive(Serialize, Deserialize)]
-    enum EnumSkipAll {
+    pub enum EnumSkipAll {
         #[serde(skip_deserializing)]
         #[allow(dead_code)]
         Variant,
     }
 
     #[derive(Serialize, Deserialize)]
-    enum EmptyVariants {
+    pub enum EmptyVariants {
         Braced {},
         Tuple(),
         BracedSkip {
@@ -352,7 +354,7 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    enum EmptyVariantsDenyUnknown {
+    pub enum EmptyVariantsDenyUnknown {
         Braced {},
         Tuple(),
         BracedSkip {
@@ -364,21 +366,21 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct UnitDenyUnknown;
+    pub struct UnitDenyUnknown;
 
     #[derive(Serialize, Deserialize)]
-    struct EmptyArray {
+    pub struct EmptyArray {
         empty: [X; 0],
     }
 
-    enum Or<A, B> {
+    pub enum Or<A, B> {
         A(A),
         B(B),
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(untagged, remote = "Or")]
-    enum OrDef<A, B> {
+    pub enum OrDef<A, B> {
         A(A),
         B(B),
     }
@@ -390,7 +392,7 @@ fn test_gen() {
     struct StrDef<'a>(&'a str);
 
     #[derive(Serialize, Deserialize)]
-    struct Remote<'a> {
+    pub struct Remote<'a> {
         #[serde(with = "OrDef")]
         or: Or<u8, bool>,
         #[serde(borrow, with = "StrDef")]
@@ -398,7 +400,7 @@ fn test_gen() {
     }
 
     #[derive(Serialize, Deserialize)]
-    enum BorrowVariant<'a> {
+    pub enum BorrowVariant<'a> {
         #[serde(borrow, with = "StrDef")]
         S(Str<'a>),
     }
@@ -415,15 +417,14 @@ fn test_gen() {
 
     // This would not work if SDef::serialize / deserialize are private.
     #[derive(Serialize, Deserialize)]
-    struct RemoteVisibility {
+    pub struct RemoteVisibility {
         #[serde(with = "vis::SDef")]
         s: vis::S,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(remote = "Self")]
-    #[allow(dead_code)]
-    struct RemoteSelf;
+    pub struct RemoteSelf;
 
     #[derive(Serialize, Deserialize)]
     enum ExternallyTaggedVariantWith {
@@ -548,25 +549,25 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct FlattenDenyUnknown<T> {
+    pub struct FlattenDenyUnknown<T> {
         #[serde(flatten)]
         t: T,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct StaticStrStruct<'a> {
+    pub struct StaticStrStruct<'a> {
         a: &'a str,
         b: &'static str,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct StaticStrTupleStruct<'a>(&'a str, &'static str);
+    pub struct StaticStrTupleStruct<'a>(&'a str, &'static str);
 
     #[derive(Serialize, Deserialize)]
-    struct StaticStrNewtypeStruct(&'static str);
+    pub struct StaticStrNewtypeStruct(&'static str);
 
     #[derive(Serialize, Deserialize)]
-    enum StaticStrEnum<'a> {
+    pub enum StaticStrEnum<'a> {
         Struct { a: &'a str, b: &'static str },
         Tuple(&'a str, &'static str),
         Newtype(&'static str),
@@ -640,6 +641,7 @@ fn test_gen() {
             use serde_derive::{Deserialize, Serialize};
 
             #[derive(Serialize, Deserialize)]
+            #[allow(dead_code)]
             struct Restricted {
                 pub(super) a: usize,
                 pub(in super::inner) b: usize,
@@ -649,7 +651,7 @@ fn test_gen() {
 
     #[derive(Deserialize)]
     #[serde(tag = "t", content = "c")]
-    enum AdjacentlyTaggedVoid {}
+    pub enum AdjacentlyTaggedVoid {}
 
     #[derive(Serialize, Deserialize)]
     enum SkippedVariant<T> {
@@ -662,14 +664,13 @@ fn test_gen() {
     assert::<SkippedVariant<X>>();
 
     #[derive(Deserialize)]
-    struct ImplicitlyBorrowedOption<'a> {
-        #[allow(dead_code)]
+    pub struct ImplicitlyBorrowedOption<'a> {
         option: std::option::Option<&'a str>,
     }
 
     #[derive(Serialize, Deserialize)]
     #[serde(untagged)]
-    enum UntaggedNewtypeVariantWith {
+    pub enum UntaggedNewtypeVariantWith {
         Newtype(
             #[serde(serialize_with = "ser_x")]
             #[serde(deserialize_with = "de_x")]
@@ -679,7 +680,7 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     #[serde(transparent)]
-    struct TransparentWith {
+    pub struct TransparentWith {
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         x: X,
@@ -701,35 +702,49 @@ fn test_gen() {
     }
 
     #[derive(Deserialize)]
-    struct RelObject<'a> {
-        #[allow(dead_code)]
+    pub struct RelObject<'a> {
         ty: &'a str,
-        #[allow(dead_code)]
         id: String,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct FlattenSkipSerializing<T> {
+    pub struct FlattenSkipSerializing<T> {
         #[serde(flatten, skip_serializing)]
         #[allow(dead_code)]
         flat: T,
     }
 
     #[derive(Serialize, Deserialize)]
-    struct FlattenSkipSerializingIf<T> {
+    pub struct FlattenSkipSerializingIf<T> {
         #[serde(flatten, skip_serializing_if = "StdOption::is_none")]
         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)]
-    struct FlattenSkipDeserializing<T> {
-        #[serde(flatten, skip_deserializing)]
-        flat: T,
+    #[serde(untagged)]
+    pub enum Inner<T> {
+        Builder {
+            s: T,
+            #[serde(flatten)]
+            o: T,
+        },
+        Default {
+            s: T,
+        },
     }
 
     // https://github.com/serde-rs/serde/issues/1804
     #[derive(Serialize, Deserialize)]
-    enum Message {
+    pub enum Message {
         #[serde(skip)]
         #[allow(dead_code)]
         String(String),
@@ -748,8 +763,7 @@ fn test_gen() {
     macro_rules! deriving {
         ($field:ty) => {
             #[derive(Deserialize)]
-            struct MacroRules<'a> {
-                #[allow(dead_code)]
+            pub struct MacroRules<'a> {
                 field: $field,
             }
         };
@@ -764,22 +778,20 @@ fn test_gen() {
     }
 
     #[derive(Deserialize)]
-    struct BorrowLifetimeInsideMacro<'a> {
+    pub struct BorrowLifetimeInsideMacro<'a> {
         #[serde(borrow = "'a")]
-        #[allow(dead_code)]
-        f: mac!(Cow<'a, str>),
+        pub f: mac!(Cow<'a, str>),
     }
 
     #[derive(Serialize)]
-    #[allow(dead_code)]
-    struct Struct {
+    pub struct Struct {
         #[serde(serialize_with = "vec_first_element")]
-        vec: Vec<Self>,
+        pub vec: Vec<Self>,
     }
 
     #[derive(Deserialize)]
     #[serde(bound(deserialize = "[&'de str; N]: Copy"))]
-    struct GenericUnitStruct<const N: usize>;
+    pub struct GenericUnitStruct<const N: usize>;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -866,7 +878,7 @@ where
 
 #[derive(Debug, PartialEq, Deserialize)]
 #[serde(tag = "tag")]
-enum InternallyTagged {
+pub enum InternallyTagged {
     #[serde(deserialize_with = "deserialize_generic")]
     Unit,
 

test_suite/tests/test_remote.rs

@@ -7,14 +7,17 @@ mod remote {
 
     pub struct PrimitivePriv(u8);
 
+    #[allow(dead_code)]
     pub struct PrimitivePub(pub u8);
 
     pub struct NewtypePriv(Unit);
 
+    #[allow(dead_code)]
     pub struct NewtypePub(pub Unit);
 
     pub struct TuplePriv(u8, Unit);
 
+    #[allow(dead_code)]
     pub struct TuplePub(pub u8, pub Unit);
 
     pub struct StructPriv {
@@ -22,6 +25,7 @@ mod remote {
         b: Unit,
     }
 
+    #[allow(dead_code)]
     pub struct StructPub {
         pub a: u8,
         pub b: Unit,
@@ -86,12 +90,14 @@ mod remote {
         }
     }
 
+    #[allow(dead_code)]
     pub enum EnumGeneric<T> {
         Variant(T),
     }
 }
 
 #[derive(Serialize, Deserialize)]
+#[allow(dead_code)]
 struct Test {
     #[serde(with = "UnitDef")]
     unit: remote::Unit,
@@ -132,6 +138,7 @@ struct Test {
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::Unit")]
+#[allow(dead_code)]
 struct UnitDef;
 
 #[derive(Serialize, Deserialize)]
@@ -140,6 +147,7 @@ struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] u8);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::PrimitivePub")]
+#[allow(dead_code)]
 struct PrimitivePubDef(u8);
 
 #[derive(Serialize, Deserialize)]
@@ -148,6 +156,7 @@ struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with = "UnitD
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::NewtypePub")]
+#[allow(dead_code)]
 struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
 
 #[derive(Serialize, Deserialize)]
@@ -159,6 +168,7 @@ struct TuplePrivDef(
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::TuplePub")]
+#[allow(dead_code)]
 struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
 
 #[derive(Serialize, Deserialize)]
@@ -174,6 +184,7 @@ struct StructPrivDef {
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::StructPub")]
+#[allow(dead_code)]
 struct StructPubDef {
     a: u8,
 
@@ -190,17 +201,20 @@ struct StructGenericWithGetterDef<T> {
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::StructGeneric<u8>")]
+#[allow(dead_code)]
 struct StructConcrete {
     value: u8,
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::EnumGeneric<u8>")]
+#[allow(dead_code)]
 enum EnumConcrete {
     Variant(u8),
 }
 
 #[derive(Debug)]
+#[allow(dead_code)]
 enum ErrorKind {
     NotFound,
     PermissionDenied,
@@ -211,6 +225,7 @@ enum ErrorKind {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "ErrorKind")]
 #[non_exhaustive]
+#[allow(dead_code)]
 enum ErrorKindDef {
     NotFound,
     PermissionDenied,

test_suite/tests/test_self.rs

@@ -41,7 +41,7 @@ fn test_self() {
     }
 
     #[derive(Deserialize, Serialize)]
-    struct Tuple(
+    pub struct Tuple(
         Box<Self>,
         Box<<Self as Trait>::Assoc>,
         [(); Self::ASSOC],
@@ -60,7 +60,7 @@ fn test_self() {
     }
 
     #[derive(Deserialize, Serialize)]
-    enum Enum {
+    pub enum Enum {
         Struct {
             _f1: Box<Self>,
             _f2: Box<<Self as Trait>::Assoc>,