Merge #626

626: Use one trait for all cases; use constant case for structures r=burrbull a=luojia65

This pull request is the first part of #612. It merges all `ToSanitizedXxxCase` traits in one `ToSanitizedCase` trait. It also replace all use of upper cases into constant cases, in case the source file did not provide underline between words. It rename variables related to cases, for example `name_sc` to `name_snake_case` to be explict.

The changed code merges original case conversation traits into one trait:

```rust
/// Convert self string into specific case without overlapping to svd2rust internal names
pub trait ToSanitizedCase {
    /// Convert self into PascalCase.
    ///
    /// Use on name of enumeration values.
    fn to_sanitized_pascal_case(&self) -> Cow<str>;
    /// Convert self into CONSTANT_CASE.
    ///
    /// Use on name of reader structs, writer structs and enumerations.
    fn to_sanitized_constant_case(&self) -> Cow<str>;
    /// 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>;
    /// Convert self into snake_case target and ensure target is not a Rust keyword.
    ///
    /// If the sanitized target is a Rust keyword, this function adds an underline `_`
    /// to it.
    ///
    /// Use on name of peripheral modules, register modules and field modules.
    fn to_sanitized_snake_case(&self) -> Cow<str> {
        let s = self.to_sanitized_not_keyword_snake_case();
        sanitize_keyword(s)
    }
}
```

Note on replacing upper case to constant case: if the source svd file provide enumeration name `InterruptEnable`, it converts to constant case `INTERRUPT_ENABLE` instead of less readable `INTERRUPTENABLE` in current code.

Co-authored-by: luojia65 <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Use constant case for structure names; internal rearrangements for
+  case conversation traits
 - Add new feature `feature_group` which will generate cfg attribute for
   every group name when it is on
 

src/generate/device.rs

@@ -1,5 +1,4 @@
 use crate::svd::{array::names, Device, Peripheral};
-use crate::util::{ToSanitizedSnakeCase, U32Ext};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 
@@ -8,7 +7,7 @@ use std::borrow::Cow;
 use std::fs::File;
 use std::io::Write;
 
-use crate::util::{self, Config, ToSanitizedUpperCase};
+use crate::util::{self, Config, ToSanitizedCase, U32Ext};
 use crate::Target;
 use anyhow::{Context, Result};
 
@@ -261,7 +260,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
         match p {
             Peripheral::Single(_p) => {
                 let p_name = util::name_of(p, config.ignore_groups);
-                let p = p_name.to_sanitized_upper_case();
+                let p = p_name.to_sanitized_constant_case();
                 let id = Ident::new(&p, Span::call_site());
                 fields.extend(quote! {
                     #[doc = #p]
@@ -272,7 +271,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
             }
             Peripheral::Array(_p, dim_element) => {
                 let p_names: Vec<Cow<str>> = names(p, dim_element).map(|n| n.into()).collect();
-                let p = p_names.iter().map(|p| p.to_sanitized_upper_case());
+                let p = p_names.iter().map(|p| p.to_sanitized_constant_case());
                 let ids_f = p.clone().map(|p| Ident::new(&p, Span::call_site()));
                 let ids_e = ids_f.clone();
                 fields.extend(quote! {

src/generate/interrupt.rs

@@ -6,7 +6,7 @@ use cast::u64;
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 
-use crate::util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase};
+use crate::util::{self, ToSanitizedCase};
 use crate::{Config, Target};
 use anyhow::Result;
 
@@ -43,8 +43,8 @@ pub fn render(
         }
         pos += 1;
 
-        let name_uc = Ident::new(
-            &interrupt.0.name.to_sanitized_upper_case(),
+        let name_constant_case = Ident::new(
+            &interrupt.0.name.to_sanitized_constant_case(),
             Span::call_site(),
         );
         let description = format!(
@@ -78,25 +78,25 @@ pub fn render(
         variants.extend(quote! {
             #[doc = #description]
             #feature_attribute
-            #name_uc = #value,
+            #name_constant_case = #value,
         });
 
         from_arms.extend(quote! {
             #feature_attribute
-            #value => Ok(Interrupt::#name_uc),
+            #value => Ok(Interrupt::#name_constant_case),
         });
 
         if feature_attribute_flag {
             elements.extend(quote! {
                 #not_feature_attribute
                 Vector { _reserved: 0 },
                 #feature_attribute
-                Vector { _handler: #name_uc },
+                Vector { _handler: #name_constant_case },
             });
         } else {
-            elements.extend(quote!(Vector { _handler: #name_uc },));
+            elements.extend(quote!(Vector { _handler: #name_constant_case },));
         }
-        names.push(name_uc);
+        names.push(name_constant_case);
         names_cfg_attr.push(feature_attribute);
     }
 

src/generate/peripheral.rs

@@ -12,8 +12,8 @@ use quote::{quote, ToTokens};
 use syn::{parse_str, Token};
 
 use crate::util::{
-    self, handle_cluster_error, handle_reg_error, unsuffixed, Config, FullName,
-    ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE,
+    self, handle_cluster_error, handle_reg_error, unsuffixed, Config, FullName, ToSanitizedCase,
+    BITS_PER_BYTE,
 };
 use anyhow::{anyhow, bail, Context, Result};
 
@@ -44,16 +44,16 @@ pub fn render(
 
     let name = util::name_of(p, config.ignore_groups);
     let span = Span::call_site();
-    let name_str = name.to_sanitized_upper_case();
-    let name_pc = Ident::new(&name_str, span);
+    let name_str = name.to_sanitized_constant_case();
+    let name_constant_case = Ident::new(&name_str, span);
     let address = util::hex(p.base_address as u64);
     let description = util::respace(p.description.as_ref().unwrap_or(&p.name));
 
-    let name_sc = Ident::new(&name.to_sanitized_snake_case(), span);
+    let name_snake_case = Ident::new(&name.to_sanitized_snake_case(), span);
     let (derive_regs, base) = if let (Some(df), None) = (p_derivedfrom, &p_original.registers) {
         (true, Ident::new(&df.name.to_sanitized_snake_case(), span))
     } else {
-        (false, name_sc.clone())
+        (false, name_snake_case.clone())
     };
 
     let feature_attribute = if config.feature_group && p.group_name.is_some() {
@@ -66,8 +66,8 @@ pub fn render(
     match p_original {
         Peripheral::Array(p, dim) => {
             let names: Vec<Cow<str>> = names(p, dim).map(|n| n.into()).collect();
-            let names_str = names.iter().map(|n| n.to_sanitized_upper_case());
-            let names_pc = names_str.clone().map(|n| Ident::new(&n, span));
+            let names_str = names.iter().map(|n| n.to_sanitized_constant_case());
+            let names_constant_case = names_str.clone().map(|n| Ident::new(&n, span));
             let addresses =
                 (0..=dim.dim).map(|i| util::hex(p.base_address + (i * dim.dim_increment) as u64));
 
@@ -76,13 +76,13 @@ pub fn render(
                 #(
                     #[doc = #description]
                     #feature_attribute
-                    pub struct #names_pc { _marker: PhantomData<*const ()> }
+                    pub struct #names_constant_case { _marker: PhantomData<*const ()> }
 
                     #feature_attribute
-                    unsafe impl Send for #names_pc {}
+                    unsafe impl Send for #names_constant_case {}
 
                     #feature_attribute
-                    impl #names_pc {
+                    impl #names_constant_case {
                         ///Pointer to the register block
                         pub const PTR: *const #base::RegisterBlock = #addresses as *const _;
 
@@ -94,7 +94,7 @@ pub fn render(
                     }
 
                     #feature_attribute
-                    impl Deref for #names_pc {
+                    impl Deref for #names_constant_case {
                         type Target = #base::RegisterBlock;
 
                         #[inline(always)]
@@ -104,7 +104,7 @@ pub fn render(
                     }
 
                     #feature_attribute
-                    impl core::fmt::Debug for #names_pc {
+                    impl core::fmt::Debug for #names_constant_case {
                         fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                             f.debug_struct(#names_str).finish()
                         }
@@ -117,13 +117,13 @@ pub fn render(
             out.extend(quote! {
                 #[doc = #description]
                 #feature_attribute
-                pub struct #name_pc { _marker: PhantomData<*const ()> }
+                pub struct #name_constant_case { _marker: PhantomData<*const ()> }
 
                 #feature_attribute
-                unsafe impl Send for #name_pc {}
+                unsafe impl Send for #name_constant_case {}
 
                 #feature_attribute
-                impl #name_pc {
+                impl #name_constant_case {
                     ///Pointer to the register block
                     pub const PTR: *const #base::RegisterBlock = #address as *const _;
 
@@ -135,7 +135,7 @@ pub fn render(
                 }
 
                 #feature_attribute
-                impl Deref for #name_pc {
+                impl Deref for #name_constant_case {
                     type Target = #base::RegisterBlock;
 
                     #[inline(always)]
@@ -145,7 +145,7 @@ pub fn render(
                 }
 
                 #feature_attribute
-                impl core::fmt::Debug for #name_pc {
+                impl core::fmt::Debug for #name_constant_case {
                     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                         f.debug_struct(#name_str).finish()
                     }
@@ -161,7 +161,7 @@ pub fn render(
         out.extend(quote! {
             #[doc = #description]
             #feature_attribute
-            pub use #base as #name_sc;
+            pub use #base as #name_snake_case;
         });
         return Ok(out);
     }
@@ -235,7 +235,7 @@ pub fn render(
     out.extend(quote! {
         #[doc = #description]
         #feature_attribute
-        pub mod #name_sc #open
+        pub mod #name_snake_case #open
     });
 
     out.extend(mod_items);
@@ -627,7 +627,7 @@ fn register_or_cluster_block(
 
     let name = Ident::new(
         &match name {
-            Some(name) => name.to_sanitized_upper_case(),
+            Some(name) => name.to_sanitized_constant_case(),
             None => "RegisterBlock".into(),
         },
         span,
@@ -963,7 +963,7 @@ fn cluster_block(
 ) -> Result<TokenStream> {
     let mut mod_items = TokenStream::new();
 
-    // name_sc needs to take into account array type.
+    // name_snake_case needs to take into account array type.
     let description =
         util::escape_brackets(util::respace(c.description.as_ref().unwrap_or(&c.name)).as_ref());
 
@@ -975,7 +975,7 @@ fn cluster_block(
         },
         "",
     );
-    let name_sc = Ident::new(&mod_name.to_sanitized_snake_case(), Span::call_site());
+    let name_snake_case = Ident::new(&mod_name.to_sanitized_snake_case(), Span::call_site());
 
     let reg_block = register_or_cluster_block(&c.children, Some(&mod_name), config)?;
 
@@ -1006,7 +1006,7 @@ fn cluster_block(
 
         ///Register block
         #[doc = #description]
-        pub mod #name_sc {
+        pub mod #name_snake_case {
             #mod_items
         }
     })
@@ -1157,10 +1157,10 @@ fn name_to_ty_str<'a, 'b>(name: &'a str, ns: Option<&'b str>) -> Cow<'a, str> {
             String::from("self::")
                 + &ns.to_sanitized_snake_case()
                 + "::"
-                + &name.to_sanitized_upper_case(),
+                + &name.to_sanitized_constant_case(),
         )
     } else {
-        name.to_sanitized_upper_case()
+        name.to_sanitized_constant_case()
     }
 }
 
@@ -1175,13 +1175,13 @@ fn name_to_wrapped_ty_str(name: &str, ns: Option<&str>) -> String {
             "crate::Reg<self::{}::{}::{}_SPEC>",
             &ns.to_sanitized_snake_case(),
             &name.to_sanitized_snake_case(),
-            &name.to_sanitized_upper_case(),
+            &name.to_sanitized_constant_case(),
         )
     } else {
         format!(
             "crate::Reg<{}::{}_SPEC>",
             &name.to_sanitized_snake_case(),
-            &name.to_sanitized_upper_case(),
+            &name.to_sanitized_constant_case(),
         )
     }
 }