zephyr-build: Fix clippy warnings

These are all straightforward source transformations, suggested by
clippy, that make the code more idiomatic Rust.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr-build/src/devicetree.rs

@@ -5,13 +5,13 @@
 //! different ways:
 //!
 //! - Canonical DTS.  There is a single DTS file (`build/zephyr/zephyr.dts`) that contains the final
-//! tree, but still in DTS format (the DTB file would have information discarded).
+//!   tree, but still in DTS format (the DTB file would have information discarded).
 //!
 //! - Generated.  The C header `devicetree_generated.h` contains all of the definitions.  This isn't
-//! a particularly friendly file to read or parse, but it does have one piece of information that is
-//! not represented anywhere else: the mapping between devicetree nodes and their "ORD" index.  The
-//! device nodes in the system are indexed by this number, and we need this in order to be able to
-//! reference the nodes from Rust.
+//!   a particularly friendly file to read or parse, but it does have one piece of information that is
+//!   not represented anywhere else: the mapping between devicetree nodes and their "ORD" index.  The
+//!   device nodes in the system are indexed by this number, and we need this in order to be able to
+//!   reference the nodes from Rust.
 //!
 //! Beyond the ORD field, it seems easier to deal with the DTS file itself.  Parsing is fairly
 //! straightforward, as it is a subset of the DTS format, and we only have to be able to deal with

zephyr-build/src/devicetree/augment.rs

@@ -112,12 +112,10 @@ fn parent_compatible(node: &Node, names: &[String], level: usize) -> bool {
     // runs on the host, so the stack is easier.
     if level == 0 {
         names.iter().any(|n| node.is_compatible(n))
+    } else if let Some(parent) = node.parent.borrow().as_ref() {
+        parent_compatible(parent, names, level - 1)
     } else {
-        if let Some(parent) = node.parent.borrow().as_ref() {
-            parent_compatible(parent, names, level - 1)
-        } else {
-            false
-        }
+        false
     }
 }
 

zephyr-build/src/devicetree/output.rs

@@ -22,7 +22,7 @@ impl DeviceTree {
         // Root is a little special.  Since we don't want a module for this (it will be provided
         // above where it is included, so it can get documentation and attributes), we use None for
         // the name.
-        self.node_walk(self.root.as_ref(), None, &augments)
+        self.node_walk(self.root.as_ref(), None, augments)
     }
 
     // Write, to the given writer, CFG lines so that Rust code can conditionalize based on the DT.
@@ -98,14 +98,11 @@ impl DeviceTree {
             match value {
                 Value::Words(ref words) => {
                     if words.len() == 1 {
-                        match &words[0] {
-                            Word::Number(n) => {
-                                let tag = dt_to_upper_id(&prop.name);
-                                return quote! {
-                                    pub const #tag: u32 = #n;
-                                };
-                            }
-                            _ => (),
+                        if let Word::Number(n) = &words[0] {
+                            let tag = dt_to_upper_id(&prop.name);
+                            return quote! {
+                                pub const #tag: u32 = #n;
+                            };
                         }
                     }
                 }
@@ -173,15 +170,13 @@ impl Property {
     // If this property is a single top-level phandle, output that a that path is valid.  It isn't a
     // real node, but acts like one.
     fn output_path<W: Write>(&self, write: &mut W, name: &str) -> Result<()> {
-        if let Some(value) = self.get_single_value() {
-            if let Value::Phandle(_) = value {
-                writeln!(
-                    write,
-                    "cargo:rustc-cfg=dt=\"{}::{}\"",
-                    name,
-                    fix_id(&self.name)
-                )?;
-            }
+        if let Some(Value::Phandle(_)) = self.get_single_value() {
+            writeln!(
+                write,
+                "cargo:rustc-cfg=dt=\"{}::{}\"",
+                name,
+                fix_id(&self.name)
+            )?;
         }
         Ok(())
     }

zephyr-build/src/devicetree/parse.rs

@@ -60,7 +60,7 @@ impl<'a> TreeBuilder<'a> {
         println!("Root: {:?} {}", name, ord);
         */
 
-        let mut name = LazyName::new(path, route.to_owned(), &self.ords);
+        let mut name = LazyName::new(path, route.to_owned(), self.ords);
         let mut labels = Vec::new();
         let mut properties = Vec::new();
         let mut children = Vec::new();
@@ -79,7 +79,7 @@ impl<'a> TreeBuilder<'a> {
                 }
                 Rule::node => {
                     let child_path = name.path_ref();
-                    children.push(self.walk_node(pair, child_path, &name.route_ref()));
+                    children.push(self.walk_node(pair, child_path, name.route_ref()));
                 }
                 r => panic!("node: {:?}", r),
             }
@@ -140,7 +140,7 @@ fn decode_property(node: Pair<'_, Rule>) -> Property {
     }
 }
 
-fn decode_words<'i>(node: Pair<'i, Rule>) -> Vec<Word> {
+fn decode_words(node: Pair<'_, Rule>) -> Vec<Word> {
     let mut value = Vec::new();
     for pair in node.into_inner() {
         match pair.as_rule() {
@@ -151,7 +151,7 @@ fn decode_words<'i>(node: Pair<'i, Rule>) -> Vec<Word> {
             }
             Rule::decimal_number => {
                 let text = pair.as_str();
-                let num = u32::from_str_radix(text, 10).unwrap();
+                let num = text.parse::<u32>().unwrap();
                 value.push(Word::Number(num));
             }
             Rule::phandle => {
@@ -165,7 +165,7 @@ fn decode_words<'i>(node: Pair<'i, Rule>) -> Vec<Word> {
     value
 }
 
-fn decode_bytes<'i>(node: Pair<'i, Rule>) -> Vec<u8> {
+fn decode_bytes(node: Pair<'_, Rule>) -> Vec<u8> {
     let mut value = Vec::new();
     for pair in node.into_inner() {
         match pair.as_rule() {

zephyr-build/src/lib.rs

@@ -135,10 +135,7 @@ pub fn dt_cfgs() {
 
 /// Determine if `rustfmt` is in the path, and can be excecuted. Returns false on any kind of error.
 pub fn has_rustfmt() -> bool {
-    match Command::new("rustfmt").arg("--version").status() {
-        Ok(st) if st.success() => true,
-        _ => false,
-    }
+    matches!(Command::new("rustfmt").arg("--version").status(), Ok(st) if st.success())
 }
 
 /// Attempt to write the contents to a file, using rustfmt. If there is an error running rustfmt,