Implement display name for content fields

When generating code for a XSD schema that defines a `content` attribute,
the corresponding field in the generated code will conflict with the field
generated for the actual content of that element. To fix this we introduced
a user defined display name for the generated content field.

Author: Bergmann89

xsd-parser/src/config/generator.rs

@@ -53,6 +53,12 @@ pub struct GeneratorConfig {
     /// See [`Generator::any_attributes_type`](crate::Generator::any_attributes_type)
     /// for details.
     pub any_attributes_type: String,
+
+    /// Name to use for the generated content field of the generated types.
+    ///
+    /// See [`Generator::content_display_name`](crate::Generator::content_display_name)
+    /// for details.
+    pub content_display_name: String,
 }
 
 impl Default for GeneratorConfig {
@@ -69,6 +75,7 @@ impl Default for GeneratorConfig {
             nillable_type: "::xsd_parser_types::xml::Nillable".into(),
             any_type: "::xsd_parser_types::xml::AnyElement".into(),
             any_attributes_type: "::xsd_parser_types::xml::AnyAttributes".into(),
+            content_display_name: "content".into(),
         }
     }
 }

xsd-parser/src/config/mod.rs

@@ -51,6 +51,13 @@ pub struct Config {
 }
 
 impl Config {
+    /// Set the name to use for the generated content field of the generated types.
+    pub fn with_content_display_name<S: Into<String>>(mut self, name: S) -> Self {
+        self.generator.content_display_name = name.into();
+
+        self
+    }
+
     /// Adds the passed `schema` to the list of schemas to parse.
     pub fn with_schema<T>(mut self, schema: T) -> Self
     where

xsd-parser/src/lib.rs

@@ -356,7 +356,8 @@ pub fn exec_generator_with_ident_cache<'types>(
     let mut generator = Generator::new(types)
         .flags(config.flags)
         .box_flags(config.box_flags)
-        .typedef_mode(config.typedef_mode);
+        .typedef_mode(config.typedef_mode)
+        .content_display_name(config.content_display_name);
 
     generator = generator
         .text_type(config.text_type)

xsd-parser/src/models/data/complex.rs

@@ -196,6 +196,9 @@ pub struct ComplexDataContent<'types> {
     /// Maximum occurrence.
     pub max_occurs: MaxOccurs,
 
+    /// Field identifier of the element.
+    pub field_ident: Ident2,
+
     /// Actual target type of the content.
     pub target_type: PathData,
 

xsd-parser/src/pipeline/generator/data/complex.rs

@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 use std::mem::take;
 
+use inflector::Inflector;
 use proc_macro2::{Ident as Ident2, Literal};
 use quote::format_ident;
 
@@ -23,6 +24,7 @@ use crate::models::{
     ElementIdent, TypeIdent,
 };
 use crate::pipeline::generator::ValueGeneratorMode;
+use crate::Name;
 
 use super::super::{Context, Error};
 
@@ -172,6 +174,7 @@ impl<'types> ComplexData<'types> {
     ) -> Result<Self, Error> {
         let base = ComplexBase::new(ctx, form, ComplexFlags::empty())?;
         let occurs = Occurs::from_occurs(min_occurs, max_occurs);
+        let field_ident = format_ident!("{}", ctx.content_display_name);
 
         let content_ref = ctx.get_or_create_type_ref_for_value(simple_type, occurs.is_direct())?;
         let target_type = content_ref.path.clone();
@@ -189,6 +192,7 @@ impl<'types> ComplexData<'types> {
             simple_type: Some(simple_type),
             min_occurs,
             max_occurs,
+            field_ident,
             target_type,
             extra_attributes: Vec::new(),
         };
@@ -206,6 +210,7 @@ impl<'types> ComplexData<'types> {
         })
     }
 
+    #[allow(clippy::too_many_lines)]
     fn new_enum(
         ctx: &mut Context<'_, 'types>,
         form: FormChoiceType,
@@ -303,6 +308,7 @@ impl<'types> ComplexData<'types> {
             }
         } else {
             let type_ref = ctx.current_type_ref();
+            let field_ident = format_ident!("{}", ctx.content_display_name);
 
             let target_type = (*type_ref.path).clone().with_ident(content_ident.clone());
             let target_type = PathData::from_path(target_type);
@@ -312,6 +318,7 @@ impl<'types> ComplexData<'types> {
                 simple_type: None,
                 min_occurs,
                 max_occurs,
+                field_ident,
                 target_type,
                 extra_attributes: Vec::new(),
             };
@@ -472,6 +479,7 @@ impl<'types> ComplexData<'types> {
             }
         } else {
             let type_ref = ctx.current_type_ref();
+            let field_ident = format_ident!("{}", ctx.content_display_name);
 
             let target_type = (*type_ref.path).clone().with_ident(content_ident.clone());
             let target_type = PathData::from_path(target_type);
@@ -481,6 +489,7 @@ impl<'types> ComplexData<'types> {
                 simple_type: None,
                 min_occurs,
                 max_occurs,
+                field_ident,
                 target_type,
                 extra_attributes: Vec::new(),
             };
@@ -716,8 +725,13 @@ impl<'types> ComplexDataElement<'types> {
         max_occurs: MaxOccurs,
         content_ident: Ident2,
     ) -> Self {
+        let s_name = ctx.content_display_name.clone();
+        let b_name = Literal::byte_string(s_name.as_bytes());
+        let field_ident = format_ident!("{s_name}");
+        let variant_ident = format_ident!("{}", s_name.to_pascal_case());
+
         let meta = ElementMeta {
-            ident: ElementIdent::named("content"),
+            ident: ElementIdent::new(Name::new_named(s_name.clone())),
             variant: ElementMetaVariant::Type {
                 type_: TypeIdent::UNKNOWN,
                 mode: ElementMode::Group,
@@ -741,11 +755,11 @@ impl<'types> ComplexDataElement<'types> {
         Self {
             origin,
             occurs,
-            s_name: "content".into(),
-            b_name: Literal::byte_string(b"content"),
+            s_name,
+            b_name,
             tag_name: TagName::default(),
-            field_ident: format_ident!("content"),
-            variant_ident: format_ident!("Content"),
+            field_ident,
+            variant_ident,
             target_type,
             need_indirection: false,
             target_is_dynamic: false,

xsd-parser/src/pipeline/generator/meta.rs

@@ -40,6 +40,9 @@ pub struct MetaData<'types> {
 
     /// Type to use to store unstructured `xs:anyAttribute` attributes.
     pub any_attributes_type: IdentPath,
+
+    /// Name to use for the generated content field of the generated types.
+    pub content_display_name: String,
 }
 
 impl MetaData<'_> {

xsd-parser/src/pipeline/generator/mod.rs

@@ -113,6 +113,7 @@ impl<'types> Generator<'types> {
             any_type: IdentPath::from_str("::xsd_parser_types::xml::AnyElement").unwrap(),
             any_attributes_type: IdentPath::from_str("::xsd_parser_types::xml::AnyAttributes")
                 .unwrap(),
+            content_display_name: String::from("content"),
         };
         let state = State {
             cache: BTreeMap::new(),
@@ -215,6 +216,13 @@ impl<'types> Generator<'types> {
         Ok(self)
     }
 
+    /// Set the name to use for the generated content field of the generated types.
+    pub fn content_display_name<S: Into<String>>(mut self, name: S) -> Self {
+        self.meta.content_display_name = name.into();
+
+        self
+    }
+
     /// Add the passed [`GeneratorFlags`] flags the generator should use for generating the code.
     pub fn with_flags(mut self, value: GeneratorFlags) -> Self {
         self.meta.flags |= value;

xsd-parser/src/pipeline/renderer/steps/quick_xml/collect_namespaces.rs

@@ -209,9 +209,11 @@ impl ComplexDataStruct<'_> {
 
         let field_calls: Vec<_> = match &self.mode {
             StructMode::Empty { .. } => Vec::new(),
-            StructMode::Content { .. } => {
+            StructMode::Content { content } => {
+                let field_ident = &content.field_ident;
+
                 vec![quote! {
-                    self.content.collect_namespaces(helper, bytes);
+                    self.#field_ident.collect_namespaces(helper, bytes);
                 }]
             }
             StructMode::All { elements, .. } | StructMode::Sequence { elements, .. } => elements

xsd-parser/src/pipeline/renderer/steps/quick_xml/deserialize.rs

@@ -2379,6 +2379,7 @@ impl ComplexDataContent<'_> {
     }
 
     fn deserializer_field_decl(&self, ctx: &Context<'_, '_>) -> TokenStream {
+        let field_ident = &self.field_ident;
         let target_type = ctx.resolve_type_for_deserialize_module(&self.target_type);
 
         let target_type = match self.occurs {
@@ -2396,60 +2397,64 @@ impl ComplexDataContent<'_> {
         };
 
         quote! {
-            content: #target_type,
+            #field_ident: #target_type,
         }
     }
 
     fn deserializer_struct_field_init(&self, ctx: &Context<'_, '_>) -> TokenStream {
+        let field_ident = &self.field_ident;
+
         match self.occurs {
             Occurs::None => quote!(),
-            Occurs::Single | Occurs::Optional => quote!(content: None,),
+            Occurs::Single | Occurs::Optional => quote!(#field_ident: None,),
             Occurs::DynamicList | Occurs::StaticList(_) => {
                 let vec = resolve_build_in!(ctx, "::alloc::vec::Vec");
 
-                quote!(content: #vec::new(),)
+                quote!(#field_ident: #vec::new(),)
             }
         }
     }
 
     fn deserializer_struct_field_finish(&self, ctx: &mut Context<'_, '_>) -> TokenStream {
+        let field_ident = &self.field_ident;
         let convert = match self.occurs {
             Occurs::None => crate::unreachable!(),
             Occurs::Single => {
                 if ctx.has_defaultable_content() {
-                    quote!(helper.finish_default(self.content)?)
+                    quote!(helper.finish_default(self.#field_ident)?)
                 } else {
-                    quote!(helper.finish_content(self.content)?)
+                    quote!(helper.finish_content(self.#field_ident)?)
                 }
             }
             Occurs::Optional => {
-                quote! { self.content }
+                quote! { self.#field_ident }
             }
             Occurs::DynamicList => {
                 let min = self.min_occurs;
                 let max = self.max_occurs.render_opt();
 
                 if ctx.has_defaultable_content() {
-                    quote!(helper.finish_vec_default(#min, self.content)?)
+                    quote!(helper.finish_vec_default(#min, self.#field_ident)?)
                 } else {
-                    quote!(helper.finish_vec(#min, #max, self.content)?)
+                    quote!(helper.finish_vec(#min, #max, self.#field_ident)?)
                 }
             }
             Occurs::StaticList(sz) => {
                 if ctx.has_defaultable_content() {
-                    quote!(helper.finish_arr_default::<_, #sz>(self.content)?)
+                    quote!(helper.finish_arr_default::<_, #sz>(self.#field_ident)?)
                 } else {
-                    quote!(helper.finish_arr::<_, #sz>(self.content)?)
+                    quote!(helper.finish_arr::<_, #sz>(self.#field_ident)?)
                 }
             }
         };
 
         quote! {
-            content: #convert,
+            #field_ident: #convert,
         }
     }
 
     fn deserializer_struct_field_fn_store(&self, ctx: &Context<'_, '_>) -> TokenStream {
+        let field_ident = &self.field_ident;
         let target_type = ctx.resolve_type_for_deserialize_module(&self.target_type);
 
         let body = match self.occurs {
@@ -2459,15 +2464,15 @@ impl ComplexDataContent<'_> {
                     resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::ErrorKind");
 
                 quote! {
-                    if self.content.is_some() {
+                    if self.#field_ident.is_some() {
                         Err(#error_kind::DuplicateContent)?;
                     }
 
-                    self.content = Some(value);
+                    self.#field_ident = Some(value);
                 }
             }
             Occurs::DynamicList | Occurs::StaticList(_) => quote! {
-                self.content.push(value);
+                self.#field_ident.push(value);
             },
         };
 

xsd-parser/src/pipeline/renderer/steps/quick_xml/serialize.rs

@@ -1193,6 +1193,8 @@ impl ComplexDataContent<'_> {
         ctx: &Context<'_, '_>,
         state_ident: &Ident2,
     ) -> TokenStream {
+        let field_ident = &self.field_ident;
+
         match self.occurs {
             Occurs::None => crate::unreachable!(),
             Occurs::Single => {
@@ -1201,7 +1203,7 @@ impl ComplexDataContent<'_> {
 
                 quote! {
                     *self.state = #state_ident::Content__(
-                        #with_serializer::serializer(&self.value.content, None, false)?
+                        #with_serializer::serializer(&self.value.#field_ident, None, false)?
                     )
                 }
             }
@@ -1212,7 +1214,7 @@ impl ComplexDataContent<'_> {
                 quote! {
                     *self.state = #state_ident::Content__(
                         #iter_serializer::new(
-                            self.value.content.as_ref(),
+                            self.value.#field_ident.as_ref(),
                             None,
                             false
                         )
@@ -1226,7 +1228,7 @@ impl ComplexDataContent<'_> {
                 quote! {
                     *self.state = #state_ident::Content__(
                         #iter_serializer::new(
-                            &self.value.content[..],
+                            &self.value.#field_ident[..],
                             None,
                             false
                         )