Merge #645

645: type aliases in RegisterBlock r=Emilgardis a=burrbull



Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>

Author: bors[bot]

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Use register aliases in `RegisterBlock`
 - Create aliases for derived registers & clusters
 - Move cluster struct inside mod
 - Support non-sequential field arrays

src/generate/peripheral.rs

@@ -9,8 +9,8 @@ use quote::{quote, ToTokens};
 use syn::{punctuated::Punctuated, Token};
 
 use crate::util::{
-    self, array_proxy_type, name_to_ty, name_to_wrapped_ty, new_syn_u32, path_segment, type_path,
-    unsuffixed, Config, FullName, ToSanitizedCase, BITS_PER_BYTE,
+    self, array_proxy_type, name_to_ty, new_syn_u32, path_segment, type_path, unsuffixed, Config,
+    FullName, ToSanitizedCase, BITS_PER_BYTE,
 };
 use anyhow::{anyhow, bail, Context, Result};
 
@@ -655,7 +655,7 @@ fn expand_cluster(cluster: &Cluster, config: &Config) -> Result<Vec<RegisterBloc
     } else {
         util::replace_suffix(&cluster.name, "")
     };
-    let ty = syn::Type::Path(name_to_ty(&ty_name));
+    let ty = name_to_ty(&ty_name);
 
     match cluster {
         Cluster::Single(info) => {
@@ -776,7 +776,7 @@ fn expand_register(register: &Register, config: &Config) -> Result<Vec<RegisterB
     } else {
         util::replace_suffix(&info_name, "")
     };
-    let ty = name_to_wrapped_ty(&ty_name);
+    let ty = name_to_ty(&ty_name);
 
     match register {
         Register::Single(info) => {
@@ -928,55 +928,47 @@ fn cluster_block(
     let name_snake_case = mod_name.to_snake_case_ident(span);
     let name_constant_case = mod_name.to_constant_case_ident(span);
 
-    let struct_path = name_to_ty(&mod_name);
-
-    let mod_items = if let Some(dpath) = dpath {
+    if let Some(dpath) = dpath {
         let dparent = util::parent(&dpath);
         let mut derived = if &dparent == path {
-            let mut segments = Punctuated::new();
-            segments.push(path_segment(Ident::new("super", span)));
-            type_path(segments)
+            type_path(Punctuated::new())
         } else {
             util::block_path_to_ty(&dparent, span)
         };
         let dname = util::replace_suffix(&index.clusters.get(&dpath).unwrap().name, "");
-        derived
-            .path
-            .segments
-            .push(path_segment(dname.to_snake_case_ident(span)));
         derived
             .path
             .segments
             .push(path_segment(dname.to_constant_case_ident(span)));
 
-        quote! {
+        Ok(quote! {
             #[doc = #description]
             pub use #derived as #name_constant_case;
-        }
+        })
     } else {
         let cpath = path.new_cluster(&c.name);
         let mod_items = render_ercs(&mut c.children, &cpath, index, config)?;
 
         // Generate the register block.
         let reg_block = register_or_cluster_block(&c.children, Some(&mod_name), config)?;
 
-        quote! {
+        let mod_items = quote! {
             #reg_block
 
             #mod_items
-        }
-    };
+        };
 
-    Ok(quote! {
-        #[doc = #description]
-        pub use #struct_path;
+        Ok(quote! {
+            #[doc = #description]
+            pub use #name_snake_case::#name_constant_case;
 
-        ///Cluster
-        #[doc = #description]
-        pub mod #name_snake_case {
-            #mod_items
-        }
-    })
+            ///Cluster
+            #[doc = #description]
+            pub mod #name_snake_case {
+                #mod_items
+            }
+        })
+    }
 }
 
 fn new_syn_field(ident: Ident, ty: syn::Type) -> syn::Field {

src/generate/register.rs

@@ -36,45 +36,40 @@ pub fn render(
         }))
         .as_ref(),
     );
-    let alias_doc =
-        format!("{name} register accessor: an alias for `Reg<{name_constant_case_spec}>`");
-    let wrapped_name = util::name_to_wrapped_ty(&name);
-    out.extend(quote! {
-        #[doc = #alias_doc]
-        pub type #name_constant_case = #wrapped_name;
-    });
 
-    let mod_items = if let Some(dpath) = dpath.as_ref() {
-        let mut derived_spec = if &dpath.block == path {
-            let mut segments = Punctuated::new();
-            segments.push(path_segment(Ident::new("super", span)));
-            type_path(segments)
+    if let Some(dpath) = dpath.as_ref() {
+        let mut derived = if &dpath.block == path {
+            type_path(Punctuated::new())
         } else {
             util::block_path_to_ty(&dpath.block, span)
         };
         let dname = util::name_of(index.registers.get(dpath).unwrap(), config.ignore_groups);
-        derived_spec
+        derived
             .path
             .segments
-            .push(path_segment(dname.to_snake_case_ident(span)));
-        derived_spec.path.segments.push(path_segment(
-            format!("{}_SPEC", dname).to_constant_case_ident(span),
-        ));
+            .push(path_segment(dname.to_constant_case_ident(span)));
 
-        quote! {
+        out.extend(quote! {
             #[doc = #description]
-            pub use #derived_spec as #name_constant_case_spec;
-        }
+            pub use #derived as #name_constant_case;
+        });
     } else {
-        render_register_mod(register, &path.new_register(&register.name), index, config)?
-    };
+        let alias_doc =
+            format!("{name} register accessor: an alias for `Reg<{name_constant_case_spec}>`");
+        out.extend(quote! {
+            #[doc = #alias_doc]
+            pub type #name_constant_case = crate::Reg<#name_snake_case::#name_constant_case_spec>;
+        });
+        let mod_items =
+            render_register_mod(register, &path.new_register(&register.name), index, config)?;
 
-    out.extend(quote! {
-        #[doc = #description]
-        pub mod #name_snake_case {
-            #mod_items
-        }
-    });
+        out.extend(quote! {
+            #[doc = #description]
+            pub mod #name_snake_case {
+                #mod_items
+            }
+        });
+    };
 
     Ok(out)
 }

src/util.rs

@@ -367,38 +367,11 @@ pub fn array_proxy_type(ty: Type, array_info: &DimElement) -> Type {
     Type::Path(type_path(segments))
 }
 
-pub fn name_to_ty(name: &str) -> TypePath {
+pub fn name_to_ty(name: &str) -> Type {
     let span = Span::call_site();
     let mut segments = Punctuated::new();
-    segments.push(path_segment(name.to_snake_case_ident(span)));
     segments.push(path_segment(name.to_constant_case_ident(span)));
-    type_path(segments)
-}
-
-pub fn name_to_wrapped_ty(name: &str) -> Type {
-    let span = Span::call_site();
-    let mut segments = Punctuated::new();
-    segments.push(path_segment(name.to_snake_case_ident(span)));
-    segments.push(path_segment(
-        format!("{name}_SPEC").to_constant_case_ident(span),
-    ));
-    let inner_path = GenericArgument::Type(Type::Path(type_path(segments)));
-    let mut args = Punctuated::new();
-    args.push(inner_path);
-    let arguments = PathArguments::AngleBracketed(AngleBracketedGenericArguments {
-        colon2_token: None,
-        lt_token: Token![<](span),
-        args,
-        gt_token: Token![>](span),
-    });
-
-    let mut segments = Punctuated::new();
-    segments.push(path_segment(Ident::new("crate", span)));
-    segments.push(PathSegment {
-        ident: Ident::new("Reg", span),
-        arguments,
-    });
-    Type::Path(type_path(segments))
+    syn::Type::Path(type_path(segments))
 }
 
 pub fn block_path_to_ty(bpath: &svd_parser::expand::BlockPath, span: Span) -> TypePath {