more cleanups

Author: burrbull

src/generate/peripheral.rs

@@ -10,10 +10,7 @@ use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::{parse_str, Token};
 
-use crate::util::{
-    self, handle_cluster_error, handle_reg_error, unsuffixed, Config, FullName, ToSanitizedCase,
-    BITS_PER_BYTE,
-};
+use crate::util::{self, unsuffixed, Config, FullName, ToSanitizedCase, BITS_PER_BYTE};
 use anyhow::{anyhow, bail, Context, Result};
 
 use crate::generate::register;
@@ -570,26 +567,24 @@ fn expand(ercs: &[RegisterCluster], config: &Config) -> Result<Vec<RegisterBlock
     debug!("Expanding registers or clusters into Register Block Fields");
     for erc in ercs {
         match &erc {
-            RegisterCluster::Register(register) => match expand_register(register, config) {
-                Ok(expanded_reg) => {
-                    trace!("Register: {}", register.name);
-                    ercs_expanded.extend(expanded_reg);
-                }
-                Err(e) => {
-                    let res = Err(e);
-                    return handle_reg_error("Error expanding register", register, res);
-                }
-            },
-            RegisterCluster::Cluster(cluster) => match expand_cluster(cluster, config) {
-                Ok(expanded_cluster) => {
-                    trace!("Cluster: {}", cluster.name);
-                    ercs_expanded.extend(expanded_cluster);
-                }
-                Err(e) => {
-                    let res = Err(e);
-                    return handle_cluster_error("Error expanding register cluster", cluster, res);
-                }
-            },
+            RegisterCluster::Register(register) => {
+                let reg_name = &register.name;
+                let expanded_reg = expand_register(register, config).with_context(|| {
+                    let descrip = register.description.as_deref().unwrap_or("No description");
+                    format!("Error expanding register\nName: {reg_name}\nDescription: {descrip}")
+                })?;
+                trace!("Register: {reg_name}");
+                ercs_expanded.extend(expanded_reg);
+            }
+            RegisterCluster::Cluster(cluster) => {
+                let cluster_name = &cluster.name;
+                let expanded_cluster = expand_cluster(cluster, config).with_context(|| {
+                    let descrip = cluster.description.as_deref().unwrap_or("No description");
+                    format!("Error expanding cluster\nName: {cluster_name}\nDescription: {descrip}")
+                })?;
+                trace!("Cluster: {cluster_name}");
+                ercs_expanded.extend(expanded_cluster);
+            }
         };
     }
 
@@ -880,14 +875,17 @@ fn render_ercs(
                 if let Some(dpath) = dpath {
                     rpath = derive_register(reg, &dpath, path, index)?;
                 }
-                let rpath = rpath.unwrap_or_else(|| path.new_register(&reg.name));
-                match register::render(reg, &rpath, index, config) {
-                    Ok(rendered_reg) => mod_items.extend(rendered_reg),
-                    Err(e) => {
-                        let res: Result<TokenStream> = Err(e);
-                        return handle_reg_error("Error rendering register", reg, res);
-                    }
-                };
+                let reg_name = &reg.name;
+                let rpath = rpath.unwrap_or_else(|| path.new_register(reg_name));
+
+                let rendered_reg =
+                    register::render(reg, &rpath, index, config).with_context(|| {
+                        let descrip = reg.description.as_deref().unwrap_or("No description");
+                        format!(
+                            "Error rendering register\nName: {reg_name}\nDescription: {descrip}"
+                        )
+                    })?;
+                mod_items.extend(rendered_reg)
             }
         }
     }

src/util.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use crate::svd::{Access, Cluster, Device, Field, Register, RegisterInfo, RegisterProperties};
+use crate::svd::{Access, Device, Field, RegisterInfo, RegisterProperties};
 use inflections::Inflect;
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 use svd_rs::{MaybeArray, PeripheralInfo};
 use syn::parse_str;
 
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{anyhow, bail, Result};
 
 pub const BITS_PER_BYTE: u32 = 8;
 
@@ -424,22 +424,6 @@ pub fn build_rs() -> TokenStream {
     }
 }
 
-pub fn handle_reg_error<T>(msg: &str, reg: &Register, res: Result<T>) -> Result<T> {
-    let reg_name = &reg.name;
-    let descrip = reg.description.as_deref().unwrap_or("No description");
-    handle_erc_error(msg, reg_name, descrip, res)
-}
-
-pub fn handle_cluster_error<T>(msg: &str, cluster: &Cluster, res: Result<T>) -> Result<T> {
-    let cluster_name = &cluster.name;
-    let descrip = cluster.description.as_deref().unwrap_or("No description");
-    handle_erc_error(msg, cluster_name, descrip, res)
-}
-
-fn handle_erc_error<T>(msg: &str, name: &str, descrip: &str, res: Result<T>) -> Result<T> {
-    res.with_context(|| format!("{msg}\nName: {name}\nDescription: {descrip}"))
-}
-
 pub fn get_register_sizes(d: &Device) -> Vec<u32> {
     let mut reg_sizes = HashSet::new();
     for p in &d.peripherals {