to_xx_case_ident

Author: burrbull

src/generate/peripheral.rs

@@ -35,13 +35,9 @@ pub fn render(p_original: &Peripheral, index: &Index, config: &Config) -> Result
     let address = util::hex(p.base_address as u64);
     let description = util::respace(p.description.as_ref().unwrap_or(&p.name));
 
-    let name_snake_case = Ident::new(&name.to_sanitized_snake_case(), span);
+    let name_snake_case = name.to_snake_case_ident(span);
     let (derive_regs, base, path) = if let Some(path) = path {
-        (
-            true,
-            Ident::new(&path.peripheral.to_sanitized_snake_case(), span),
-            path,
-        )
+        (true, path.peripheral.to_snake_case_ident(span), path)
     } else {
         (false, name_snake_case.clone(), BlockPath::new(&p.name))
     };
@@ -705,13 +701,11 @@ fn expand_cluster(
                     let mut accessors = TokenStream::new();
                     let nb_name = util::replace_suffix(&info.name, "");
                     let ty = name_to_ty(&nb_name, name)?;
-                    let nb_name_cs = Ident::new(&nb_name.to_sanitized_snake_case(), span);
+                    let nb_name_cs = nb_name.to_snake_case_ident(span);
                     let description = info.description.as_ref().unwrap_or(&info.name);
                     for (i, idx) in array_info.indexes().enumerate() {
-                        let idx_name = Ident::new(
-                            &util::replace_suffix(&info.name, &idx).to_sanitized_snake_case(),
-                            span,
-                        );
+                        let idx_name =
+                            util::replace_suffix(&info.name, &idx).to_snake_case_ident(span);
                         let comment = make_comment(
                             cluster_size,
                             info.address_offset + (i as u32) * cluster_size / 8,
@@ -814,14 +808,12 @@ fn expand_register(
                     let mut accessors = TokenStream::new();
                     let nb_name = util::replace_suffix(&info.fullname(config.ignore_groups), "");
                     let ty = name_to_wrapped_ty(&nb_name, name)?;
-                    let nb_name_cs = Ident::new(&nb_name.to_sanitized_snake_case(), span);
+                    let nb_name_cs = nb_name.to_snake_case_ident(span);
                     let description = info.description.clone().unwrap_or_default();
                     let info_name = info.fullname(config.ignore_groups);
                     for (i, idx) in array_info.indexes().enumerate() {
-                        let idx_name = Ident::new(
-                            &util::replace_suffix(&info_name, &idx).to_sanitized_snake_case(),
-                            span,
-                        );
+                        let idx_name =
+                            util::replace_suffix(&info_name, &idx).to_snake_case_ident(span);
                         let comment = make_comment(
                             register_size,
                             info.address_offset + (i as u32) * register_size / 8,
@@ -933,7 +925,7 @@ fn cluster_block(
     let description =
         util::escape_brackets(&util::respace(c.description.as_ref().unwrap_or(&c.name)));
 
-    let name_snake_case = Ident::new(&mod_name.to_sanitized_snake_case(), Span::call_site());
+    let name_snake_case = mod_name.to_snake_case_ident(Span::call_site());
 
     Ok(quote! {
         #reg_block
@@ -962,7 +954,10 @@ fn expand_svd_register(
 
             let ty = name_to_wrapped_ty(&ty_name, name)?;
 
-            out.push(new_syn_field(&nb_name.to_sanitized_snake_case(), ty));
+            out.push(new_syn_field(
+                nb_name.to_snake_case_ident(Span::call_site()),
+                ty,
+            ));
         }
         Ok(out)
     } else {
@@ -981,7 +976,7 @@ fn convert_svd_register(
             let info_name = info.fullname(ignore_group);
             let ty = name_to_wrapped_ty(&info_name, name)
                 .with_context(|| format!("Error converting register name {info_name}"))?;
-            new_syn_field(&info_name.to_sanitized_snake_case(), ty)
+            new_syn_field(info_name.to_snake_case_ident(Span::call_site()), ty)
         }
         Register::Array(info, array_info) => {
             let info_name = info.fullname(ignore_group);
@@ -990,7 +985,7 @@ fn convert_svd_register(
                 .with_context(|| format!("Error converting register name {nb_name}"))?;
             let array_ty = new_syn_array(ty, array_info.dim)?;
 
-            new_syn_field(&nb_name.to_sanitized_snake_case(), array_ty)
+            new_syn_field(nb_name.to_snake_case_ident(Span::call_site()), array_ty)
         }
     })
 }
@@ -1011,7 +1006,10 @@ fn array_proxy(
     ))?;
 
     Ok(RegisterBlockField {
-        syn_field: new_syn_field(&ty_name.to_sanitized_snake_case(), ap_path.into()),
+        syn_field: new_syn_field(
+            ty_name.to_snake_case_ident(Span::call_site()),
+            ap_path.into(),
+        ),
         description: info.description.as_ref().unwrap_or(&info.name).into(),
         offset: info.address_offset,
         size: 0,
@@ -1034,7 +1032,10 @@ fn expand_svd_cluster(
 
             let ty = name_to_ty(&ty_name, name)?;
 
-            out.push(new_syn_field(&nb_name.to_sanitized_snake_case(), ty));
+            out.push(new_syn_field(
+                nb_name.to_snake_case_ident(Span::call_site()),
+                ty,
+            ));
         }
         Ok(out)
     } else {
@@ -1048,22 +1049,22 @@ fn convert_svd_cluster(cluster: &Cluster, name: Option<&str>) -> Result<syn::Fie
         Cluster::Single(info) => {
             let ty_name = util::replace_suffix(&info.name, "");
             let ty = name_to_ty(&ty_name, name)?;
-            new_syn_field(&info.name.to_sanitized_snake_case(), ty)
+            new_syn_field(info.name.to_snake_case_ident(Span::call_site()), ty)
         }
         Cluster::Array(info, array_info) => {
             let ty_name = util::replace_suffix(&info.name, "");
             let ty = name_to_ty(&ty_name, name)?;
             let array_ty = new_syn_array(ty, array_info.dim)?;
 
-            new_syn_field(&ty_name.to_sanitized_snake_case(), array_ty)
+            new_syn_field(ty_name.to_snake_case_ident(Span::call_site()), array_ty)
         }
     })
 }
 
-fn new_syn_field(ident: &str, ty: syn::Type) -> syn::Field {
+fn new_syn_field(ident: Ident, ty: syn::Type) -> syn::Field {
     let span = Span::call_site();
     syn::Field {
-        ident: Some(Ident::new(ident, span)),
+        ident: Some(ident),
         vis: syn::Visibility::Public(syn::VisPublic {
             pub_token: Token![pub](span),
         }),

src/generate/register.rs

@@ -25,12 +25,9 @@ pub fn render(
     let access = util::access_of(properties, register.fields.as_deref());
     let name = util::name_of(register, config.ignore_groups);
     let span = Span::call_site();
-    let name_constant_case = Ident::new(&name.to_sanitized_constant_case(), span);
-    let name_constant_case_spec = Ident::new(
-        &format!("{}_SPEC", &name.to_sanitized_constant_case()),
-        span,
-    );
-    let name_snake_case = Ident::new(&name.to_sanitized_snake_case(), span);
+    let name_constant_case = name.to_constant_case_ident(span);
+    let name_constant_case_spec = format!("{name}_SPEC").to_constant_case_ident(span);
+    let name_snake_case = name.to_snake_case_ident(span);
     let rsize = properties
         .size
         .ok_or_else(|| anyhow!("Register {} has no `size` field", register.name))?;
@@ -348,7 +345,7 @@ pub fn fields(
         // TODO(AJM) - do we need to do anything with this range type?
         let BitRange { offset, width, .. } = f.bit_range;
         let name = util::replace_suffix(&f.name, "");
-        let name_snake_case = Ident::new(&name.to_sanitized_snake_case(), span);
+        let name_snake_case = name.to_snake_case_ident(span);
         let name_constant_case = name.to_sanitized_constant_case();
         let description_raw = f.description.as_deref().unwrap_or(""); // raw description, if absent using empty string
         let description = util::respace(&util::escape_brackets(description_raw));
@@ -456,14 +453,10 @@ pub fn fields(
             let value_read_ty = if let Some((evs, _)) = lookup_filter(&lookup_results, Usage::Read)
             {
                 if let Some(enum_name) = &evs.name {
-                    let enum_name_constant_case = enum_name.to_sanitized_constant_case();
-                    let enum_value_read_ty =
-                        Ident::new(&format!("{enum_name_constant_case}_A"), span);
-                    enum_value_read_ty
+                    format!("{enum_name}_A").to_constant_case_ident(span)
                 } else {
-                    let derived_field_value_read_ty =
-                        Ident::new(&format!("{name_constant_case}_A"), span);
-                    derived_field_value_read_ty
+                    // derived_field_value_read_ty
+                    Ident::new(&format!("{name_constant_case}_A"), span)
                 }
             } else {
                 // raw_field_value_read_ty
@@ -620,8 +613,7 @@ pub fn fields(
                 evs_r = Some(evs.clone());
                 // generate pub use field_1 reader as field_2 reader
                 let base_field = util::replace_suffix(&base.field.name, "");
-                let base_constant_case = base_field.to_sanitized_constant_case();
-                let base_r = Ident::new(&(base_constant_case + "_R"), span);
+                let base_r = (base_field + "_R").to_constant_case_ident(span);
                 if !reader_derives.contains(&reader_ty) {
                     derive_from_base(
                         mod_items,
@@ -678,10 +670,8 @@ pub fn fields(
                             self.bits
                         }
                     };
-                    let name_snake_case_n = Ident::new(
-                        &util::replace_suffix(&f.name, suffix).to_sanitized_snake_case(),
-                        Span::call_site(),
-                    );
+                    let name_snake_case_n = util::replace_suffix(&f.name, suffix)
+                        .to_snake_case_ident(Span::call_site());
                     let doc = util::replace_suffix(
                         &description_with_bits(description_raw, sub_offset, width),
                         suffix,
@@ -741,14 +731,10 @@ pub fn fields(
                         "A"
                     };
                     if let Some(enum_name) = &evs.name {
-                        let enum_name_constant_case = enum_name.to_sanitized_constant_case();
-                        let enum_value_write_ty =
-                            Ident::new(&format!("{enum_name_constant_case}_{ty_suffix}"), span);
-                        enum_value_write_ty
+                        format!("{enum_name}_{ty_suffix}").to_constant_case_ident(span)
                     } else {
-                        let derived_field_value_write_ty =
-                            Ident::new(&format!("{name_constant_case}_{ty_suffix}"), span);
-                        derived_field_value_write_ty
+                        // derived_field_value_write_ty
+                        Ident::new(&format!("{name_constant_case}_{ty_suffix}"), span)
                     }
                 } else {
                     // raw_field_value_write_ty
@@ -887,8 +873,7 @@ pub fn fields(
 
                     // generate pub use field_1 writer as field_2 writer
                     let base_field = util::replace_suffix(&base.field.name, "");
-                    let base_constant_case = base_field.to_sanitized_constant_case();
-                    let base_w = Ident::new(&(base_constant_case + "_W"), span);
+                    let base_w = (base_field + "_W").to_constant_case_ident(span);
                     if !writer_derives.contains(&writer_ty) {
                         derive_from_base(
                             mod_items,
@@ -915,10 +900,8 @@ pub fn fields(
 
                 for (i, suffix) in (0..*dim).zip(suffixes.iter()) {
                     let sub_offset = offset + (i as u64) * (*increment as u64);
-                    let name_snake_case_n = Ident::new(
-                        &util::replace_suffix(&f.name, suffix).to_sanitized_snake_case(),
-                        Span::call_site(),
-                    );
+                    let name_snake_case_n = &util::replace_suffix(&f.name, suffix)
+                        .to_snake_case_ident(Span::call_site());
                     let doc = util::replace_suffix(
                         &description_with_bits(description_raw, sub_offset, width),
                         suffix,
@@ -997,14 +980,11 @@ impl Variant {
                         .description
                         .clone()
                         .unwrap_or_else(|| format!("`{value:b}`")),
-                    pc: Ident::new(
-                        &(if pc {
-                            ev.name.to_sanitized_pascal_case()
-                        } else {
-                            ev.name.to_sanitized_constant_case()
-                        }),
-                        span,
-                    ),
+                    pc: if pc {
+                        ev.name.to_pascal_case_ident(span)
+                    } else {
+                        ev.name.to_constant_case_ident(span)
+                    },
                     nksc: Ident::new(&nksc, span),
                     sc: Ident::new(&sc, span),
                     value,
@@ -1152,8 +1132,7 @@ fn derive_from_base(
     let path = if base.register() == field.register() {
         quote! { #base_pc }
     } else if base.register().block == field.register().block {
-        let mod_ = base.register().name.to_sanitized_snake_case();
-        let mod_ = Ident::new(&mod_, span);
+        let mod_ = base.register().name.to_snake_case_ident(span);
 
         quote! { super::#mod_::#base_pc }
     } else {

src/util.rs

@@ -127,10 +127,16 @@ pub trait ToSanitizedCase {
     ///
     /// Use on name of enumeration values.
     fn to_sanitized_pascal_case(&self) -> Cow<str>;
+    fn to_pascal_case_ident(&self, span: Span) -> Ident {
+        Ident::new(&self.to_sanitized_pascal_case(), span)
+    }
     /// Convert self into CONSTANT_CASE.
     ///
     /// Use on name of reader structs, writer structs and enumerations.
     fn to_sanitized_constant_case(&self) -> Cow<str>;
+    fn to_constant_case_ident(&self, span: Span) -> Ident {
+        Ident::new(&self.to_sanitized_constant_case(), span)
+    }
     /// Convert self into snake_case, must use only if the target is used with extra prefix or suffix.
     fn to_sanitized_not_keyword_snake_case(&self) -> Cow<str>; // snake_case
     /// Convert self into snake_case target and ensure target is not a Rust keyword.
@@ -143,6 +149,9 @@ pub trait ToSanitizedCase {
         let s = self.to_sanitized_not_keyword_snake_case();
         sanitize_keyword(s)
     }
+    fn to_snake_case_ident(&self, span: Span) -> Ident {
+        Ident::new(&self.to_sanitized_snake_case(), span)
+    }
 }
 
 impl ToSanitizedCase for str {