Rename functions and run cargo fmt

serde_derive/src/de.rs

@@ -312,18 +312,18 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
         deserialize_try_from(type_try_from)
     } else if let attr::Identifier::No = cont.attrs.identifier() {
         match &cont.data {
-            Data::Enum(variants) => enum_::deserialize_enum(params, variants, &cont.attrs),
+            Data::Enum(variants) => enum_::generate_body(params, variants, &cont.attrs),
             Data::Struct(Style::Struct, fields) => {
-                struct_::deserialize_struct(params, fields, &cont.attrs, StructForm::Struct)
+                struct_::generate_body(params, fields, &cont.attrs, StructForm::Struct)
             }
             Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-                tuple::deserialize_tuple(params, fields, &cont.attrs, TupleForm::Tuple)
+                tuple::generate_body(params, fields, &cont.attrs, TupleForm::Tuple)
             }
-            Data::Struct(Style::Unit, _) => unit::deserialize_unit_struct(params, &cont.attrs),
+            Data::Struct(Style::Unit, _) => unit::generate_body(params, &cont.attrs),
         }
     } else {
         match &cont.data {
-            Data::Enum(variants) => identifier::deserialize_custom_identifier(params, variants, &cont.attrs),
+            Data::Enum(variants) => identifier::generate_body(params, variants, &cont.attrs),
             Data::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
         }
     }
@@ -349,10 +349,10 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
 
     let code = match &cont.data {
         Data::Struct(Style::Struct, fields) => {
-            struct_::deserialize_struct_in_place(params, fields, &cont.attrs)?
+            struct_::generate_body_in_place(params, fields, &cont.attrs)?
         }
         Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-            tuple::deserialize_tuple_in_place(params, fields, &cont.attrs)
+            tuple::generate_body_in_place(params, fields, &cont.attrs)
         }
         Data::Enum(_) | Data::Struct(Style::Unit, _) => {
             return None;

serde_derive/src/de/enum_.rs

@@ -12,7 +12,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 
 /// Generates `Deserialize::deserialize` body for an `enum Enum {...}`
-pub fn deserialize_enum(
+pub fn generate_body(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
@@ -30,7 +30,7 @@ pub fn deserialize_enum(
                     return _serde::#private::Ok(__ok);
                 }
             };
-            enum_untagged::deserialize_untagged_enum(params, untagged, cattrs, Some(tagged_frag))
+            enum_untagged::generate_body(params, untagged, cattrs, Some(tagged_frag))
         }
         None => deserialize_homogeneous_enum(params, variants, cattrs),
     }
@@ -42,14 +42,14 @@ fn deserialize_homogeneous_enum(
     cattrs: &attr::Container,
 ) -> Fragment {
     match cattrs.tag() {
-        attr::TagType::External => enum_externally::deserialize_externally_tagged_enum(params, variants, cattrs),
+        attr::TagType::External => enum_externally::generate_body(params, variants, cattrs),
         attr::TagType::Internal { tag } => {
-            enum_internally::deserialize_internally_tagged_enum(params, variants, cattrs, tag)
+            enum_internally::generate_body(params, variants, cattrs, tag)
         }
         attr::TagType::Adjacent { tag, content } => {
-            enum_adjacently::deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content)
+            enum_adjacently::generate_body(params, variants, cattrs, tag, content)
         }
-        attr::TagType::None => enum_untagged::deserialize_untagged_enum(params, variants, cattrs, None),
+        attr::TagType::None => enum_untagged::generate_body(params, variants, cattrs, None),
     }
 }
 
@@ -84,7 +84,7 @@ pub fn prepare_enum_variant_enum(variants: &[Variant]) -> (TokenStream, Stmts) {
         })
         .collect();
 
-    let variant_visitor = Stmts(identifier::deserialize_generated_identifier(
+    let variant_visitor = Stmts(identifier::generate_identifier(
         &deserialized_variants,
         false, // variant identifiers do not depend on the presence of flatten fields
         true,

serde_derive/src/de/enum_adjacently.rs

@@ -16,7 +16,7 @@ use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 
 /// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(tag, content)]` attributes
-pub fn deserialize_adjacently_tagged_enum(
+pub fn generate_body(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
@@ -37,7 +37,7 @@ pub fn deserialize_adjacently_tagged_enum(
         .map(|(i, variant)| {
             let variant_index = field_i(i);
 
-            let block = Match(enum_untagged::deserialize_untagged_variant(params, variant, cattrs));
+            let block = Match(enum_untagged::generate_variant(params, variant, cattrs));
 
             quote! {
                 __Field::#variant_index => #block

serde_derive/src/de/enum_externally.rs

@@ -8,9 +8,8 @@ use crate::de::enum_;
 use crate::de::struct_;
 use crate::de::tuple;
 use crate::de::{
-    expr_is_missing, field_i,
+    expr_is_missing, field_i, unwrap_to_variant_closure, wrap_deserialize_field_with,
-    unwrap_to_variant_closure, wrap_deserialize_field_with, wrap_deserialize_with, Parameters,
+    wrap_deserialize_with, Parameters, StructForm, TupleForm,
-    StructForm, TupleForm,
 };
 use crate::fragment::{Expr, Fragment, Match};
 use crate::internals::ast::{Field, Style, Variant};
@@ -21,7 +20,7 @@ use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 
 /// Generates `Deserialize::deserialize` body for an `enum Enum {...}` without additional attributes
-pub fn deserialize_externally_tagged_enum(
+pub fn generate_body(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
@@ -144,13 +143,13 @@ fn deserialize_externally_tagged_variant(
             &variant.fields[0],
             cattrs,
         ),
-        Style::Tuple => tuple::deserialize_tuple(
+        Style::Tuple => tuple::generate_body(
             params,
             &variant.fields,
             cattrs,
             TupleForm::ExternallyTagged(variant_ident),
         ),
-        Style::Struct => struct_::deserialize_struct(
+        Style::Struct => struct_::generate_body(
             params,
             &variant.fields,
             cattrs,

serde_derive/src/de/enum_internally.rs

@@ -9,8 +9,7 @@ use crate::de::enum_;
 use crate::de::enum_untagged;
 use crate::de::struct_;
 use crate::de::{
-    effective_style, expr_is_missing, field_i,
+    effective_style, expr_is_missing, field_i, unwrap_to_variant_closure, Parameters, StructForm,
-    unwrap_to_variant_closure, Parameters, StructForm,
 };
 use crate::fragment::{Expr, Fragment, Match};
 use crate::internals::ast::{Style, Variant};
@@ -19,7 +18,7 @@ use crate::private;
 use quote::quote;
 
 /// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(tag)]` attribute
-pub fn deserialize_internally_tagged_enum(
+pub fn generate_body(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
@@ -94,9 +93,9 @@ fn deserialize_internally_tagged_variant(
             }
         }
         Style::Newtype => {
-            enum_untagged::deserialize_untagged_newtype_variant(variant_ident, params, &variant.fields[0])
+            enum_untagged::generate_newtype_variant(variant_ident, params, &variant.fields[0])
         }
-        Style::Struct => struct_::deserialize_struct(
+        Style::Struct => struct_::generate_body(
             params,
             &variant.fields,
             cattrs,

serde_derive/src/de/enum_untagged.rs

@@ -8,8 +8,7 @@
 use crate::de::struct_;
 use crate::de::tuple;
 use crate::de::{
-    effective_style, expr_is_missing,
+    effective_style, expr_is_missing, unwrap_to_variant_closure, Parameters, StructForm, TupleForm,
-    unwrap_to_variant_closure, Parameters, StructForm, TupleForm,
 };
 use crate::fragment::{Expr, Fragment};
 use crate::internals::ast::{Field, Style, Variant};
@@ -20,7 +19,7 @@ use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 
 /// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(untagged)]` attribute
-pub fn deserialize_untagged_enum(
+pub fn generate_body(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,
@@ -29,7 +28,7 @@ pub fn deserialize_untagged_enum(
     let attempts = variants
         .iter()
         .filter(|variant| !variant.attrs.skip_deserializing())
-        .map(|variant| Expr(deserialize_untagged_variant(params, variant, cattrs)));
+        .map(|variant| Expr(generate_variant(params, variant, cattrs)));
     // TODO this message could be better by saving the errors from the failed
     // attempts. The heuristic used by TOML was to count the number of fields
     // processed before an error, and use the error that happened after the
@@ -59,7 +58,8 @@ pub fn deserialize_untagged_enum(
     }
 }
 
-pub fn deserialize_untagged_variant(
+// Also used by adjacently tagged enums
+pub fn generate_variant(
     params: &Parameters,
     variant: &Variant,
     cattrs: &attr::Container,
@@ -92,16 +92,14 @@ pub fn deserialize_untagged_variant(
                 }
             }
         }
-        Style::Newtype => {
+        Style::Newtype => generate_newtype_variant(variant_ident, params, &variant.fields[0]),
-            deserialize_untagged_newtype_variant(variant_ident, params, &variant.fields[0])
+        Style::Tuple => tuple::generate_body(
-        }
-        Style::Tuple => tuple::deserialize_tuple(
             params,
             &variant.fields,
             cattrs,
             TupleForm::Untagged(variant_ident),
         ),
-        Style::Struct => struct_::deserialize_struct(
+        Style::Struct => struct_::generate_body(
             params,
             &variant.fields,
             cattrs,
@@ -110,7 +108,9 @@ pub fn deserialize_untagged_variant(
     }
 }
 
-pub fn deserialize_untagged_newtype_variant(
+// Also used by internally tagged enums
+// Implicitly (via `generate_variant`) used by adjacently tagged enums
+pub fn generate_newtype_variant(
     variant_ident: &syn::Ident,
     params: &Parameters,
     field: &Field,

serde_derive/src/de/identifier.rs

@@ -8,7 +8,7 @@ use crate::private;
 use proc_macro2::{Literal, TokenStream};
 use quote::{quote, ToTokens};
 
-pub fn deserialize_generated_identifier(
+pub fn generate_identifier(
     deserialized_fields: &[FieldWithAliases],
     has_flatten: bool,
     is_variant: bool,
@@ -70,7 +70,7 @@ pub fn deserialize_generated_identifier(
 
 // Generates `Deserialize::deserialize` body for an enum with
 // `serde(field_identifier)` or `serde(variant_identifier)` attribute.
-pub fn deserialize_custom_identifier(
+pub fn generate_body(
     params: &Parameters,
     variants: &[Variant],
     cattrs: &attr::Container,

serde_derive/src/de/struct_.rs

@@ -1,7 +1,7 @@
 use crate::de::identifier;
 use crate::de::{
-    deserialize_seq, expr_is_missing, field_i, has_flatten,
+    deserialize_seq, expr_is_missing, field_i, has_flatten, wrap_deserialize_field_with,
-    wrap_deserialize_field_with, FieldWithAliases, Parameters, StructForm,
+    FieldWithAliases, Parameters, StructForm,
 };
 #[cfg(feature = "deserialize_in_place")]
 use crate::de::{deserialize_seq_in_place, place_lifetime};
@@ -14,7 +14,7 @@ use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 
 /// Generates `Deserialize::deserialize` body for a `struct Struct {...}`
-pub fn deserialize_struct(
+pub fn generate_body(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
@@ -197,7 +197,7 @@ pub fn deserialize_struct(
 
 /// Generates `Deserialize::deserialize_in_place` body for a `struct Struct {...}`
 #[cfg(feature = "deserialize_in_place")]
-pub fn deserialize_struct_in_place(
+pub fn generate_body_in_place(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
@@ -304,7 +304,7 @@ fn deserialize_field_identifier(
         (Some(ignore_variant), Some(fallthrough))
     };
 
-    Stmts(identifier::deserialize_generated_identifier(
+    Stmts(identifier::generate_identifier(
         deserialized_fields,
         has_flatten,
         false,

serde_derive/src/de/tuple.rs

@@ -10,7 +10,7 @@ use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 
 /// Generates `Deserialize::deserialize` body for a `struct Tuple(...);` including `struct Newtype(T);`
-pub fn deserialize_tuple(
+pub fn generate_body(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
@@ -133,7 +133,7 @@ pub fn deserialize_tuple(
 
 /// Generates `Deserialize::deserialize_in_place` body for a `struct Tuple(...);` including `struct Newtype(T);`
 #[cfg(feature = "deserialize_in_place")]
-pub fn deserialize_tuple_in_place(
+pub fn generate_body_in_place(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,

serde_derive/src/de/unit.rs

@@ -5,7 +5,7 @@ use crate::private;
 use quote::quote;
 
 /// Generates `Deserialize::deserialize` body for a `struct Unit;`
-pub fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
+pub fn generate_body(params: &Parameters, cattrs: &attr::Container) -> Fragment {
     let this_type = &params.this_type;
     let this_value = &params.this_value;
     let type_name = cattrs.name().deserialize_name();