Merge #408

408: Fix clippy lints r=burrbull a=therealprof



Co-authored-by: Daniel Egger <daniel@eggers-club.de>

Author: bors[bot]

src/generate/peripheral.rs

@@ -2,12 +2,12 @@ use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::HashMap;
 
-use quote::ToTokens;
+use crate::svd::{Cluster, ClusterInfo, Peripheral, Register, RegisterCluster, RegisterProperties};
+use log::warn;
 use proc_macro2::TokenStream;
-use crate::svd::{Cluster, ClusterInfo, RegisterProperties, Peripheral, Register, RegisterCluster};
+use proc_macro2::{Ident, Punct, Spacing, Span};
+use quote::ToTokens;
 use svd_parser::derive_from::DeriveFrom;
-use proc_macro2::{Ident, Span, Punct, Spacing};
-use log::warn;
 use syn::{parse_str, Token};
 
 use crate::errors::*;
@@ -23,16 +23,20 @@ pub fn render(
 ) -> Result<TokenStream> {
     let mut out = TokenStream::new();
 
-    let p_derivedfrom = p_original.derived_from.as_ref().and_then(|s| {
-        all_peripherals.iter().find(|x| x.name == *s)
-    });
+    let p_derivedfrom = p_original
+        .derived_from
+        .as_ref()
+        .and_then(|s| all_peripherals.iter().find(|x| x.name == *s));
 
     let p_merged = p_derivedfrom.map(|ancestor| p_original.derive_from(ancestor));
     let p = p_merged.as_ref().unwrap_or(p_original);
 
     if p_original.derived_from.is_some() && p_derivedfrom.is_none() {
-        eprintln!("Couldn't find derivedFrom original: {} for {}, skipping",
-            p_original.derived_from.as_ref().unwrap(), p_original.name);
+        eprintln!(
+            "Couldn't find derivedFrom original: {} for {}, skipping",
+            p_original.derived_from.as_ref().unwrap(),
+            p_original.name
+        );
         return Ok(out);
     }
 
@@ -93,35 +97,37 @@ pub fn render(
     // Build a map so that we can look up registers within this peripheral
     let mut reg_map = HashMap::new();
     for r in registers {
-        reg_map.insert(&r.name, r.clone());
+        reg_map.insert(&r.name, svd_parser::svd::register::Register::clone(r));
     }
 
     // Build up an alternate erc list by expanding any derived registers
-    let mut alt_erc :Vec<RegisterCluster> = registers.iter().filter_map(|r| {
-        match r.derived_from {
+    let mut alt_erc: Vec<RegisterCluster> = registers
+        .iter()
+        .filter_map(|r| match r.derived_from {
             Some(ref derived) => {
                 let ancestor = match reg_map.get(derived) {
                     Some(r) => r,
                     None => {
-                        eprintln!("register {} derivedFrom missing register {}", r.name, derived);
-                        return None
+                        eprintln!(
+                            "register {} derivedFrom missing register {}",
+                            r.name, derived
+                        );
+                        return None;
                     }
                 };
 
-                let d = match **ancestor {
-                    Register::Array(ref info, ref array_info) => {
-                        Some(RegisterCluster::Register(Register::Array(r.derive_from(info), array_info.clone())))
-                    }
-                    Register::Single(ref info) => {
-                        Some(RegisterCluster::Register(Register::Single(r.derive_from(info))))
-                    }
-                };
-
-                d
+                match *ancestor {
+                    Register::Array(ref info, ref array_info) => Some(RegisterCluster::Register(
+                        Register::Array(r.derive_from(info), array_info.clone()),
+                    )),
+                    Register::Single(ref info) => Some(RegisterCluster::Register(
+                        Register::Single(r.derive_from(info)),
+                    )),
+                }
             }
             None => Some(RegisterCluster::Register((*r).clone())),
-        }
-    }).collect();
+        })
+        .collect();
 
     // Now add the clusters to our alternate erc list
     let clusters = util::only_clusters(ercs);
@@ -507,11 +513,16 @@ fn register_or_cluster_block(
             // name, along with the region number, falling back to
             // the offset and end in case we couldn't figure out a
             // nice identifier.
-            let name = Ident::new(&format!(
-                "_reserved_{}_{}",
-                i,
-                region.compute_ident().unwrap_or_else(|| format!("{}_{}", region.offset, region.end))
-            ), span);
+            let name = Ident::new(
+                &format!(
+                    "_reserved_{}_{}",
+                    i,
+                    region
+                        .compute_ident()
+                        .unwrap_or_else(|| format!("{}_{}", region.offset, region.end))
+                ),
+                span,
+            );
             let pad = (region.end - region.offset) as usize;
             fields.extend(quote! {
                 #name: [u8; #pad],
@@ -520,10 +531,13 @@ fn register_or_cluster_block(
         last_end = region.end;
     }
 
-    let name = Ident::new(&match name {
-        Some(name) => name.to_sanitized_upper_case(),
-        None => "RegisterBlock".into(),
-    }, span);
+    let name = Ident::new(
+        &match name {
+            Some(name) => name.to_sanitized_upper_case(),
+            None => "RegisterBlock".into(),
+        },
+        span,
+    );
 
     let accessors = if have_accessors {
         quote! {
@@ -819,10 +833,10 @@ fn expand_svd_register(register: &Register, name: Option<&str>) -> Vec<syn::Fiel
 fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
     let name_to_ty = |name: &String, ns: Option<&str>| -> String {
         if let Some(ns) = ns {
-                String::from("self::")
-                    + &ns.to_sanitized_snake_case()
-                    + "::"
-                    + &name.to_sanitized_upper_case()
+            String::from("self::")
+                + &ns.to_sanitized_snake_case()
+                + "::"
+                + &name.to_sanitized_upper_case()
         } else {
             name.to_sanitized_upper_case().to_string()
         }
@@ -831,7 +845,7 @@ fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
     match register {
         Register::Single(info) => new_syn_field(
             &info.name.to_sanitized_snake_case(),
-            syn::Type::Path(parse_str::<syn::TypePath>(&name_to_ty(&info.name, name)).unwrap())
+            syn::Type::Path(parse_str::<syn::TypePath>(&name_to_ty(&info.name, name)).unwrap()),
         ),
         Register::Array(info, array_info) => {
             let has_brackets = info.name.contains("[%s]");
@@ -842,9 +856,14 @@ fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
                 info.name.replace("%s", "")
             };
 
-            let ty = syn::Type::Array(parse_str::<syn::TypeArray>(
-                &format!("[{};{}]", name_to_ty(&nb_name, name), u64::from(array_info.dim))
-            ).unwrap());
+            let ty = syn::Type::Array(
+                parse_str::<syn::TypeArray>(&format!(
+                    "[{};{}]",
+                    name_to_ty(&nb_name, name),
+                    u64::from(array_info.dim)
+                ))
+                .unwrap(),
+            );
 
             new_syn_field(&nb_name.to_sanitized_snake_case(), ty)
         }
@@ -904,7 +923,9 @@ fn convert_svd_cluster(cluster: &Cluster) -> syn::Field {
     match cluster {
         Cluster::Single(info) => new_syn_field(
             &info.name.to_sanitized_snake_case(),
-            syn::Type::Path(parse_str::<syn::TypePath>(&info.name.to_sanitized_upper_case()).unwrap())
+            syn::Type::Path(
+                parse_str::<syn::TypePath>(&info.name.to_sanitized_upper_case()).unwrap(),
+            ),
         ),
         Cluster::Array(info, array_info) => {
             let has_brackets = info.name.contains("[%s]");
@@ -915,9 +936,14 @@ fn convert_svd_cluster(cluster: &Cluster) -> syn::Field {
                 info.name.replace("%s", "")
             };
 
-            let ty = syn::Type::Array(parse_str::<syn::TypeArray>(
-                &format!("[{};{}]", &name.to_sanitized_upper_case(), u64::from(array_info.dim))
-            ).unwrap());
+            let ty = syn::Type::Array(
+                parse_str::<syn::TypeArray>(&format!(
+                    "[{};{}]",
+                    &name.to_sanitized_upper_case(),
+                    u64::from(array_info.dim)
+                ))
+                .unwrap(),
+            );
 
             new_syn_field(&name.to_sanitized_snake_case(), ty)
         }
@@ -928,7 +954,9 @@ fn new_syn_field(ident: &str, ty: syn::Type) -> syn::Field {
     let span = Span::call_site();
     syn::Field {
         ident: Some(Ident::new(ident, span)),
-        vis: syn::Visibility::Public(syn::VisPublic{ pub_token: Token![pub](span) }),
+        vis: syn::Visibility::Public(syn::VisPublic {
+            pub_token: Token![pub](span),
+        }),
         attrs: vec![],
         colon_token: Some(Token![:](span)),
         ty,