clippy

Author: burrbull

src/generate/peripheral.rs

@@ -426,14 +426,12 @@ impl FieldRegions {
             .filter(|r| {
                 r.fields.len() > 1 && (idents.iter().filter(|ident| **ident == r.ident).count() > 1)
             })
-            .inspect(|r| {
+            .for_each(|r| {
                 warn!(
                     "Found type name conflict with region {:?}, renamed to {:?}",
                     r.ident,
                     r.shortest_ident()
-                )
-            })
-            .for_each(|r| {
+                );
                 r.ident = r.shortest_ident();
             });
         Ok(())

src/generate/register.rs

@@ -3,6 +3,7 @@ use crate::svd::{
     RegisterProperties, Usage, WriteConstraint,
 };
 use cast::u64;
+use core::u64;
 use log::warn;
 use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};
 use quote::{quote, ToTokens};
@@ -254,6 +255,7 @@ pub fn render(
     Ok(out)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn fields(
     fields: &[Field],
     parent: &Register,
@@ -291,7 +293,7 @@ pub fn fields(
             && (f.access != Some(Access::WriteOnce));
         let can_write = can_write && (f.access != Some(Access::ReadOnly));
 
-        let mask = 1u64.wrapping_neg() >> (64 - width);
+        let mask = u64::MAX >> (64 - width);
         let hexmask = &util::hex(mask);
         let offset = u64::from(offset);
         let rv = reset_value.map(|rv| (rv >> offset) & mask);
@@ -749,8 +751,7 @@ pub fn fields(
 fn unsafety(write_constraint: Option<&WriteConstraint>, width: u32) -> Option<Ident> {
     match &write_constraint {
         Some(&WriteConstraint::Range(range))
-            if u64::from(range.min) == 0
-                && u64::from(range.max) == 1u64.wrapping_neg() >> (64 - width) =>
+            if range.min == 0 && range.max == u64::MAX >> (64 - width) =>
         {
             // the SVD has acknowledged that it's safe to write
             // any value that can fit in the field
@@ -1052,8 +1053,7 @@ fn lookup_in_peripheral<'p>(
     if let Some(register) = all_registers.iter().find(|r| r.name == base_register) {
         if let Some(field) = register
             .fields
-            .as_ref()
-            .map(|fs| &**fs)
+            .as_deref()
             .unwrap_or(&[])
             .iter()
             .find(|f| f.name == base_field)
@@ -1082,7 +1082,7 @@ fn lookup_in_field<'f>(
     field: &'f Field,
 ) -> Result<(&'f EnumeratedValues, Option<Base<'f>>)> {
     for evs in &field.enumerated_values {
-        if evs.name.as_ref().map(|s| &**s) == Some(base_evs) {
+        if evs.name.as_deref() == Some(base_evs) {
             return Ok((
                 evs,
                 Some(Base {
@@ -1107,11 +1107,11 @@ fn lookup_in_register<'r>(
 ) -> Result<(&'r EnumeratedValues, Option<Base<'r>>)> {
     let mut matches = vec![];
 
-    for f in register.fields.as_ref().map(|v| &**v).unwrap_or(&[]) {
+    for f in register.fields.as_deref().unwrap_or(&[]) {
         if let Some(evs) = f
             .enumerated_values
             .iter()
-            .find(|evs| evs.name.as_ref().map(|s| &**s) == Some(base_evs))
+            .find(|evs| evs.name.as_deref() == Some(base_evs))
         {
             matches.push((evs, &f.name))
         }
@@ -1168,7 +1168,7 @@ fn lookup_in_peripherals<'p>(
     }
 }
 
-fn periph_all_registers<'a>(p: &'a Peripheral) -> Vec<&'a Register> {
+fn periph_all_registers(p: &Peripheral) -> Vec<&Register> {
     let mut par: Vec<&Register> = Vec::new();
     let mut rem: Vec<&RegisterCluster> = Vec::new();
     if p.registers.is_none() {

src/lib.rs

@@ -484,20 +484,16 @@ mod util;
 
 pub use crate::util::Target;
 
+#[non_exhaustive]
 pub struct Generation {
     pub lib_rs: String,
     pub device_specific: Option<DeviceSpecific>,
-
-    // Reserve the right to add more fields to this struct
-    _extensible: (),
 }
 
+#[non_exhaustive]
 pub struct DeviceSpecific {
     pub device_x: String,
     pub build_rs: String,
-
-    // Reserve the right to add more fields to this struct
-    _extensible: (),
 }
 
 use anyhow::Result;
@@ -534,14 +530,12 @@ pub fn generate(xml: &str, target: Target, nightly: bool) -> Result<Generation>
         Some(DeviceSpecific {
             device_x,
             build_rs: util::build_rs().to_string(),
-            _extensible: (),
         })
     };
 
     Ok(Generation {
         lib_rs,
         device_specific,
-        _extensible: (),
     })
 }
 

src/util.rs

@@ -13,6 +13,7 @@ pub const BITS_PER_BYTE: u32 = 8;
 /// that are not valid in Rust ident
 const BLACKLIST_CHARS: &[char] = &['(', ')', '[', ']', '/', ' ', '-'];
 
+#[allow(non_camel_case_types)]
 #[derive(Clone, Copy, PartialEq)]
 pub enum Target {
     CortexM,
@@ -166,7 +167,7 @@ pub fn respace(s: &str) -> String {
 pub fn escape_brackets(s: &str) -> String {
     s.split('[')
         .fold("".to_string(), |acc, x| {
-            if acc == "" {
+            if acc.is_empty() {
                 x.to_string()
             } else if acc.ends_with('\\') {
                 acc + "[" + x
@@ -176,7 +177,7 @@ pub fn escape_brackets(s: &str) -> String {
         })
         .split(']')
         .fold("".to_string(), |acc, x| {
-            if acc == "" {
+            if acc.is_empty() {
                 x.to_string()
             } else if acc.ends_with('\\') {
                 acc + "]" + x