Merge pull request #819 from rust-embedded/field-derive

DimSuffix trait

Author: Emilgardis

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Use `PascalCase` for type idents, fix case changing bugs, add `--ident-format` (`-f`) option flag
 - Add `enum_read_name` for `read-only` enums, `RWEnum` helper
 - Reexport enums inside register again
+- Add `DimSuffix` helper trait
 
 ## [v0.31.5] - 2024-01-04
 

src/generate/peripheral.rs

@@ -16,7 +16,8 @@ use quote::{quote, ToTokens};
 use syn::{punctuated::Punctuated, Token};
 
 use crate::util::{
-    self, ident, name_to_ty, path_segment, type_path, unsuffixed, zst_type, FullName, BITS_PER_BYTE,
+    self, ident, name_to_ty, path_segment, type_path, unsuffixed, zst_type, DimSuffix, FullName,
+    BITS_PER_BYTE,
 };
 use anyhow::{anyhow, bail, Context, Result};
 
@@ -212,9 +213,8 @@ pub fn render(p_original: &Peripheral, index: &Index, config: &Config) -> Result
         }
     }
 
-    let description = util::escape_special_chars(
-        util::respace(p.description.as_ref().unwrap_or(&name.as_ref().to_owned())).as_ref(),
-    );
+    let description =
+        util::escape_special_chars(util::respace(p.description.as_ref().unwrap_or(&name)).as_ref());
 
     // Build up an alternate erc list by expanding any derived registers/clusters
     // erc: *E*ither *R*egister or *C*luster
@@ -763,7 +763,7 @@ fn check_erc_derive_infos(
 
                     Register::Array(..) => {
                         // Only match integer indeces when searching for disjoint arrays
-                        let re_string = util::replace_suffix(&info_name, "([0-9]+|%s)");
+                        let re_string = info_name.expand_dim("([0-9]+|%s)");
                         let re = Regex::new(format!("^{re_string}$").as_str()).map_err(|_| {
                             anyhow!("Error creating regex for register {}", register.name)
                         })?;
@@ -991,9 +991,9 @@ fn expand_cluster(cluster: &Cluster, config: &Config) -> Result<Vec<RegisterBloc
         .to_string();
 
     let ty_name = if cluster.is_single() {
-        cluster.name.to_string()
+        Cow::Borrowed(cluster.name.as_str())
     } else {
-        util::replace_suffix(&cluster.name, "")
+        cluster.name.remove_dim()
     };
     let span = Span::call_site();
     let ty = name_to_ty(ident(&ty_name, config, "cluster", span));
@@ -1166,9 +1166,9 @@ fn expand_register(
 
     let info_name = register.fullname(config.ignore_groups);
     let mut ty_name = if register.is_single() {
-        info_name.to_string()
+        info_name.clone()
     } else {
-        util::replace_suffix(&info_name, "")
+        info_name.remove_dim()
     };
     let ty_str = ty_name.clone();
 
@@ -1220,11 +1220,11 @@ fn expand_register(
             };
             let ac = match derive_info {
                 DeriveInfo::Implicit(_) => {
-                    ty_name = util::replace_suffix(&info_name, &index);
+                    ty_name = info_name.expand_dim(&index);
                     convert_list && sequential_indexes_from0
                 }
                 DeriveInfo::Explicit(_) => {
-                    ty_name = util::replace_suffix(&info_name, &index);
+                    ty_name = info_name.expand_dim(&index);
                     convert_list && sequential_indexes_from0
                 }
                 _ => convert_list,
@@ -1399,7 +1399,7 @@ fn cluster_block(
 ) -> Result<TokenStream> {
     let description =
         util::escape_special_chars(&util::respace(c.description.as_ref().unwrap_or(&c.name)));
-    let mod_name = util::replace_suffix(&c.name, "");
+    let mod_name = c.name.remove_dim().to_string();
 
     // name_snake_case needs to take into account array type.
     let span = Span::call_site();
@@ -1413,7 +1413,7 @@ fn cluster_block(
         } else {
             util::block_path_to_ty(&dparent, config, span)
         };
-        let dname = util::replace_suffix(&index.clusters.get(&dpath).unwrap().name, "");
+        let dname = index.clusters.get(&dpath).unwrap().name.remove_dim();
         let mut mod_derived = derived.clone();
         derived
             .path

src/generate/register.rs

@@ -15,8 +15,7 @@ use svd_parser::expand::{
 
 use crate::config::Config;
 use crate::util::{
-    self, ident, ident_to_path, path_segment, replace_suffix, type_path, unsuffixed, FullName,
-    U32Ext,
+    self, ident, ident_to_path, path_segment, type_path, unsuffixed, DimSuffix, FullName, U32Ext,
 };
 use anyhow::{anyhow, Result};
 use syn::punctuated::Punctuated;
@@ -55,7 +54,10 @@ pub fn render(
         if let MaybeArray::Array(info, array_info) = register {
             if let Some(dim_index) = &array_info.dim_index {
                 let index: Cow<str> = dim_index.first().unwrap().into();
-                name = replace_suffix(&info.fullname(config.ignore_groups), &index).into()
+                name = info
+                    .fullname(config.ignore_groups)
+                    .expand_dim(&index)
+                    .into()
             }
         }
     }
@@ -465,15 +467,14 @@ fn render_register_mod_debug(
             if field_access.can_read() && f.read_action.is_none() {
                 if let Field::Array(_, de) = &f {
                     for suffix in de.indexes() {
-                        let f_name_n =
-                            field_accessor(&util::replace_suffix(&f.name, &suffix), config, span);
+                        let f_name_n = field_accessor(&f.name.expand_dim(&suffix), config, span);
                         let f_name_n_s = format!("{f_name_n}");
                         r_debug_impl.extend(quote! {
                             .field(#f_name_n_s, &format_args!("{}", self.#f_name_n().#bit_or_bits()))
                         });
                     }
                 } else {
-                    let f_name = util::replace_suffix(&f.name, "");
+                    let f_name = f.name.remove_dim();
                     let f_name = field_accessor(&f_name, config, span);
                     let f_name_s = format!("{f_name}");
                     r_debug_impl.extend(quote! {
@@ -641,7 +642,7 @@ pub fn fields(
             return Err(anyhow!("incorrect field {}", f.name));
         }
 
-        let name = util::replace_suffix(&f.name, "");
+        let name = f.name.remove_dim();
         let name_snake_case = field_accessor(
             if let Field::Array(
                 _,
@@ -694,7 +695,13 @@ pub fn fields(
                     ev = (*index.evs.get(epath).unwrap()).clone();
                 }
             } else if let Some(path) = fdpath.as_ref() {
-                epath = Some(path.new_enum(ev.name.clone().unwrap_or_else(|| path.name.clone())));
+                epath = Some(
+                    path.new_enum(
+                        ev.name
+                            .clone()
+                            .unwrap_or_else(|| path.name.remove_dim().into()),
+                    ),
+                );
             }
             lookup_results.push((ev, epath));
         }
@@ -914,12 +921,7 @@ pub fn fields(
                     }
                     EV::Derived(_, base) => {
                         let base_ident = if config.field_names_for_enums {
-                            ident(
-                                &util::replace_suffix(&base.field().name, ""),
-                                config,
-                                fmt,
-                                span,
-                            )
+                            ident(&base.field().name.remove_dim(), config, fmt, span)
                         } else {
                             ident(&base.name, config, fmt, span)
                         };
@@ -980,7 +982,7 @@ pub fn fields(
                     // and value if necessary.
 
                     // generate pub use field_1 reader as field_2 reader
-                    let base_field = util::replace_suffix(&base.field.name, "");
+                    let base_field = base.field.name.remove_dim();
                     let base_r = ident(&base_field, config, "field_reader", span);
                     if !reader_derives.contains(&reader_ty) {
                         let base_path = base_syn_path(base, &fpath, &base_r, config)?;
@@ -1002,7 +1004,7 @@ pub fn fields(
 
             if let Field::Array(f, de) = &f {
                 let increment = de.dim_increment;
-                let doc = util::replace_suffix(&description, &brief_suffix);
+                let doc = description.expand_dim(&brief_suffix);
                 let first_name = svd::array::names(f, de).next().unwrap();
                 let note = format!("NOTE: `n` is number of field in register. `n == 0` corresponds to `{first_name}` field");
                 let offset_calc = calculate_offset(increment, offset, true);
@@ -1182,12 +1184,7 @@ pub fn fields(
                     }
                     EV::Derived(_, base) => {
                         let base_ident = if config.field_names_for_enums {
-                            ident(
-                                &util::replace_suffix(&base.field().name, ""),
-                                config,
-                                fmt,
-                                span,
-                            )
+                            ident(&base.field().name.remove_dim(), config, fmt, span)
                         } else {
                             ident(&base.name, config, fmt, span)
                         };
@@ -1260,7 +1257,7 @@ pub fn fields(
                 }
                 Some(EV::Derived(_, base)) => {
                     // generate pub use field_1 writer as field_2 writer
-                    let base_field = util::replace_suffix(&base.field.name, "");
+                    let base_field = base.field.name.remove_dim();
                     let base_w = ident(&base_field, config, "field_writer", span);
                     if !writer_derives.contains(&writer_ty) {
                         let base_path = base_syn_path(base, &fpath, &base_w, config)?;
@@ -1301,7 +1298,7 @@ pub fn fields(
             if let Field::Array(f, de) = &f {
                 let increment = de.dim_increment;
                 let offset_calc = calculate_offset(increment, offset, false);
-                let doc = &util::replace_suffix(&description, &brief_suffix);
+                let doc = &description.expand_dim(&brief_suffix);
                 let first_name = svd::array::names(f, de).next().unwrap();
                 let note = format!("NOTE: `n` is number of field in register. `n == 0` corresponds to `{first_name}` field");
                 let dim = unsuffixed(de.dim);
@@ -1603,7 +1600,7 @@ fn base_syn_path(
         let mut segments = Punctuated::new();
         segments.push(path_segment(Ident::new("super", span)));
         segments.push(path_segment(ident(
-            &replace_suffix(&base.register().name, ""),
+            &base.register().name.remove_dim(),
             config,
             "register_mod",
             span,

src/util.rs

@@ -184,18 +184,12 @@ pub fn escape_special_chars(s: &str) -> String {
     escape_brackets(&html_escaped)
 }
 
-pub fn name_of<T: FullName>(maybe_array: &MaybeArray<T>, ignore_group: bool) -> Cow<str> {
-    match maybe_array {
-        MaybeArray::Single(info) => info.fullname(ignore_group),
-        MaybeArray::Array(info, _) => replace_suffix(&info.fullname(ignore_group), "").into(),
-    }
-}
-
-pub fn replace_suffix(name: &str, suffix: &str) -> String {
-    if name.contains("[%s]") {
-        name.replace("[%s]", suffix)
+pub fn name_of<T: FullName>(maybe_array: &MaybeArray<T>, ignore_group: bool) -> String {
+    let fullname = maybe_array.fullname(ignore_group);
+    if maybe_array.is_array() {
+        fullname.remove_dim().into()
     } else {
-        name.replace("%s", suffix)
+        fullname.into()
     }
 }
 
@@ -433,6 +427,27 @@ pub fn build_rs() -> TokenStream {
     }
 }
 
+pub trait DimSuffix {
+    fn expand_dim(&self, suffix: &str) -> Cow<str>;
+    fn remove_dim(&self) -> Cow<str> {
+        self.expand_dim("")
+    }
+}
+
+impl DimSuffix for str {
+    fn expand_dim(&self, suffix: &str) -> Cow<str> {
+        if self.contains("%s") {
+            if self.contains("[%s]") {
+                self.replace("[%s]", suffix).into()
+            } else {
+                self.replace("%s", suffix).into()
+            }
+        } else {
+            self.into()
+        }
+    }
+}
+
 pub trait FullName {
     fn fullname(&self, ignore_group: bool) -> Cow<str>;
 }
@@ -473,7 +488,7 @@ pub fn peripheral_names(d: &Device, feature_format: &IdentFormat) -> Vec<String>
     for p in &d.peripherals {
         match p {
             Peripheral::Single(info) => {
-                v.push(replace_suffix(&feature_format.apply(&info.name), ""));
+                v.push(feature_format.apply(&info.name).remove_dim().into());
             }
             Peripheral::Array(info, dim) => {
                 v.extend(svd_rs::array::names(info, dim).map(|n| feature_format.apply(&n).into()));