Resolve name conflicts when deriving

Author: n8tlarsen

src/generate/peripheral.rs

@@ -1084,15 +1084,15 @@ fn expand_register(
     let description = register.description.clone().unwrap_or_default();
 
     let info_name = register.fullname(config.ignore_groups);
-    let ty_name = if register.is_single() {
+    let mut ty_name = if register.is_single() {
         info_name.to_string()
     } else {
         util::replace_suffix(&info_name, "")
     };
-    let ty = name_to_ty(&ty_name);
 
     match register {
         Register::Single(info) => {
+            let ty = name_to_ty(&ty_name);
             let syn_field = new_syn_field(ty_name.to_snake_case_ident(Span::call_site()), ty);
             register_expanded.push(RegisterBlockField {
                 syn_field,
@@ -1114,20 +1114,36 @@ fn expand_register(
                 false => true,
             };
 
-            // force expansion if we're implicitly deriving so we don't get name collisions
-            let array_convertible = if let DeriveInfo::Implicit(_) = derive_info {
-                false
+            // if dimIndex exists, test if it is a sequence of numbers from 0 to dim
+            let sequential_indexes_from0 = array_info
+                .indexes_as_range()
+                .filter(|r| *r.start() == 0)
+                .is_some();
+
+            // force expansion and rename if we're deriving an array that doesnt start at 0 so we don't get name collisions
+            let index: Cow<str> = if let Some(dim_index) = &array_info.dim_index {
+                dim_index.first().unwrap().into()
             } else {
-                sequential_addresses && convert_list
+                if sequential_indexes_from0 {
+                    "0".into()
+                } else {
+                    "".into()
+                }
+            };
+            let array_convertible = match derive_info {
+                DeriveInfo::Implicit(_) => {
+                    ty_name = util::replace_suffix(&info_name, &index);
+                    sequential_addresses && convert_list && sequential_indexes_from0
+                }
+                DeriveInfo::Explicit(_) => {
+                    ty_name = util::replace_suffix(&info_name, &index);
+                    sequential_addresses && convert_list && sequential_indexes_from0
+                }
+                _ => sequential_addresses && convert_list,
             };
+            let ty = name_to_ty(&ty_name);
 
             if array_convertible {
-                // if dimIndex exists, test if it is a sequence of numbers from 0 to dim
-                let sequential_indexes_from0 = array_info
-                    .indexes_as_range()
-                    .filter(|r| *r.start() == 0)
-                    .is_some();
-
                 let accessors = if sequential_indexes_from0 {
                     Vec::new()
                 } else {
@@ -1213,16 +1229,6 @@ fn render_ercs(
                 let mut rpath = None;
                 let before_name = reg.name.to_string();
                 if let DeriveInfo::Implicit(rp) = derive_info {
-                    let mut idx_name = None;
-                    let info_name = reg.fullname(config.ignore_groups).to_string();
-                    if let Register::Array(_, array_info) = reg {
-                        for (_, i) in array_info.indexes().enumerate() {
-                            idx_name = Some(util::replace_suffix(&info_name, &i).to_string());
-                        }
-                    }
-                    if let Some(name) = idx_name {
-                        reg.name = name;
-                    }
                     rpath = Some(rp.clone());
                 } else {
                     let dpath = reg.derived_from.take();

src/generate/register.rs

@@ -1,17 +1,21 @@
 use crate::svd::{
-    Access, BitRange, EnumeratedValues, Field, ModifiedWriteValues, ReadAction, Register,
-    RegisterProperties, Usage, WriteConstraint,
+    Access, BitRange, EnumeratedValues, Field, MaybeArray, ModifiedWriteValues, ReadAction,
+    Register, RegisterProperties, Usage, WriteConstraint,
 };
 use core::u64;
 use log::warn;
 use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};
 use quote::{quote, ToTokens};
+use std::borrow::Cow;
 use std::collections::HashSet;
 use svd_parser::expand::{
     derive_enumerated_values, derive_field, BlockPath, EnumPath, FieldPath, Index, RegisterPath,
 };
 
-use crate::util::{self, ident_to_path, path_segment, type_path, Config, ToSanitizedCase, U32Ext};
+use crate::util::{
+    self, ident_to_path, path_segment, replace_suffix, type_path, Config, FullName,
+    ToSanitizedCase, U32Ext,
+};
 use anyhow::{anyhow, Result};
 use syn::punctuated::Punctuated;
 
@@ -22,7 +26,17 @@ pub fn render(
     index: &Index,
     config: &Config,
 ) -> Result<TokenStream> {
-    let name = util::name_of(register, config.ignore_groups);
+    let mut name = util::name_of(register, config.ignore_groups);
+    // Rename if this is a derived array
+    if dpath.is_some() {
+        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.to_string()).into()
+            }
+        }
+    }
     let span = Span::call_site();
     let name_constant_case = name.to_constant_case_ident(span);
     let name_snake_case = name.to_snake_case_ident(span);