zephyr-build: Run cargo fmt

Run `cargo fmt` with the default rules.  This gives us a baseline to be
able to require properly formatted code for future changes.

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

Author: d3zd3z

zephyr-build/src/devicetree.rs

@@ -28,7 +28,7 @@ mod ordmap;
 mod output;
 mod parse;
 
-pub use augment::{Augment, load_augments};
+pub use augment::{load_augments, Augment};
 
 /// Representation of a parsed device tree.
 pub struct DeviceTree {
@@ -97,8 +97,7 @@ impl DeviceTree {
     pub fn new<P1: AsRef<Path>, P2: AsRef<Path>>(dts_path: P1, dt_gen: P2) -> DeviceTree {
         let ords = OrdMap::new(dt_gen);
 
-        let dts = std::fs::read_to_string(dts_path)
-            .expect("Reading zephyr.dts file");
+        let dts = std::fs::read_to_string(dts_path).expect("Reading zephyr.dts file");
         let dt = parse::parse(&dts, &ords);
 
         // Walk the node tree, fixing any phandles to include their reference.
@@ -167,32 +166,32 @@ impl Node {
     /// Returns the slice of values of a property with this name as `Some` or `None` if the property
     /// does not exist.
     fn get_property(&self, name: &str) -> Option<&[Value]> {
-        self.properties
-            .iter()
-            .find_map(|p| if p.name == name { Some(p.value.as_slice()) } else { None })
+        self.properties.iter().find_map(|p| {
+            if p.name == name {
+                Some(p.value.as_slice())
+            } else {
+                None
+            }
+        })
     }
 
     /// Attempt to retrieve the named property, as a single entry of Words.
     fn get_words(&self, name: &str) -> Option<&[Word]> {
-        self.get_property(name)
-            .and_then(|p| {
-                match p {
-                    &[Value::Words(ref w)] => Some(w.as_ref()),
-                    _ => None,
-                }
-            })
+        self.get_property(name).and_then(|p| match p {
+            &[Value::Words(ref w)] => Some(w.as_ref()),
+            _ => None,
+        })
     }
 
     /// Get a property that consists of a single number.
     fn get_number(&self, name: &str) -> Option<u32> {
-        self.get_words(name)
-            .and_then(|p| {
-                if let &[Word::Number(n)] = p {
-                    Some(n)
-                } else {
-                    None
-                }
-            })
+        self.get_words(name).and_then(|p| {
+            if let &[Word::Number(n)] = p {
+                Some(n)
+            } else {
+                None
+            }
+        })
     }
 
     /// Get a property that consists of multiple numbers.
@@ -210,14 +209,13 @@ impl Node {
 
     /// Get a property that is a single string.
     fn get_single_string(&self, name: &str) -> Option<&str> {
-        self.get_property(name)
-            .and_then(|p| {
-                if let &[Value::String(ref text)] = p {
-                    Some(text.as_ref())
-                } else {
-                    None
-                }
-            })
+        self.get_property(name).and_then(|p| {
+            if let &[Value::String(ref text)] = p {
+                Some(text.as_ref())
+            } else {
+                None
+            }
+        })
     }
 }
 
@@ -253,8 +251,7 @@ impl Phandle {
             return;
         }
 
-        let node = labels.get(&self.name).cloned()
-            .expect("Missing phandle");
+        let node = labels.get(&self.name).cloned().expect("Missing phandle");
         *self.node.borrow_mut() = Some(node);
     }
 
@@ -276,8 +273,7 @@ impl Word {
 // To avoid recursion, the debug printer for Phandle just prints the name.
 impl std::fmt::Debug for Phandle {
     fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        fmt
-            .debug_struct("Phandle")
+        fmt.debug_struct("Phandle")
             .field("name", &self.name)
             .finish_non_exhaustive()
     }

zephyr-build/src/devicetree/augment.rs

@@ -87,10 +87,7 @@ pub enum Rule {
     /// Matches if this node has one of the listed compatible strings.  The the 'level' property
     /// indicates how many levels up in the tree.  Zero means match the current node, 1 means the
     /// parent node, and so on.
-    Compatible {
-        names: Vec<String>,
-        level: usize,
-    },
+    Compatible { names: Vec<String>, level: usize },
     /// Matches at the root of tree.
     Root,
 }
@@ -143,9 +140,7 @@ pub enum Action {
 impl Action {
     fn generate(&self, _name: &Ident, node: &Node, tree: &DeviceTree) -> TokenStream {
         match self {
-            Action::Instance { raw, device } => {
-                raw.generate(node, device)
-            }
+            Action::Instance { raw, device } => raw.generate(node, device),
             Action::Labels => {
                 let nodes = tree.labels.iter().map(|(k, v)| {
                     let name = dt_to_lower_id(k);

zephyr-build/src/devicetree/ordmap.rs

@@ -2,7 +2,13 @@
 //!
 //! The OrdMap provides a mapping between nodes on the devicetree, and their "ord" index.
 
-use std::{collections::BTreeMap, fs::File, io::{BufRead, BufReader}, path::Path, str::FromStr};
+use std::{
+    collections::BTreeMap,
+    fs::File,
+    io::{BufRead, BufReader},
+    path::Path,
+    str::FromStr,
+};
 
 use regex::Regex;
 
@@ -19,8 +25,7 @@ impl OrdMap {
         let mut c_name = "".to_string();
         let mut dt_path = "".to_string();
 
-        let fd = File::open(path)
-            .expect("Opening devicetree_generated.h");
+        let fd = File::open(path).expect("Opening devicetree_generated.h");
         for line in BufReader::new(fd).lines() {
             let line = line.expect("Reading from devicetree_generated.h");
 

zephyr-build/src/devicetree/output.rs

@@ -19,7 +19,6 @@ use super::{augment::Augment, DeviceTree, Node, Property, Value, Word};
 impl DeviceTree {
     /// Generate a TokenStream for the Rust representation of this device tree.
     pub fn to_tokens(&self, augments: &[Box<dyn Augment>]) -> TokenStream {
-
         // 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.
@@ -39,15 +38,19 @@ impl DeviceTree {
         Ok(())
     }
 
-    fn node_walk(&self, node: &Node, name: Option<&str>, augments: &[Box<dyn Augment>]) -> TokenStream {
-        let children = node.children.iter().map(|child| {
-            self.node_walk(child.as_ref(), Some(&child.name), augments)
-        });
+    fn node_walk(
+        &self,
+        node: &Node,
+        name: Option<&str>,
+        augments: &[Box<dyn Augment>],
+    ) -> TokenStream {
+        let children = node
+            .children
+            .iter()
+            .map(|child| self.node_walk(child.as_ref(), Some(&child.name), augments));
         // Simplistic first pass, turn the properties into constents of the formatted text of the
         // property.
-        let props = node.properties.iter().map(|prop| {
-            self.property_walk(prop)
-        });
+        let props = node.properties.iter().map(|prop| self.property_walk(prop));
         let ord = node.ord;
 
         // Open the parent as a submodule.  This is the same as 'super', so not particularly useful.
@@ -114,7 +117,7 @@ impl DeviceTree {
                         pub mod #tag {
                             pub use #route::*;
                         }
-                    }
+                    };
                 }
                 _ => (),
             }
@@ -172,7 +175,12 @@ impl Property {
     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))?;
+                writeln!(
+                    write,
+                    "cargo:rustc-cfg=dt=\"{}::{}\"",
+                    name,
+                    fix_id(&self.name)
+                )?;
             }
         }
         Ok(())

zephyr-build/src/devicetree/parse.rs

@@ -5,7 +5,10 @@
 
 use std::{cell::RefCell, collections::BTreeMap, rc::Rc};
 
-use pest::{iterators::{Pair, Pairs}, Parser};
+use pest::{
+    iterators::{Pair, Pairs},
+    Parser,
+};
 use pest_derive::Parser;
 
 use crate::devicetree::Phandle;
@@ -17,8 +20,7 @@ use super::{ordmap::OrdMap, DeviceTree, Node, Property, Value, Word};
 pub struct Dts;
 
 pub fn parse(text: &str, ords: &OrdMap) -> DeviceTree {
-    let pairs = Dts::parse(Rule::file, text)
-        .expect("Parsing zephyr.dts");
+    let pairs = Dts::parse(Rule::file, text).expect("Parsing zephyr.dts");
 
     let b = TreeBuilder::new(ords);
     b.walk(pairs)
@@ -123,7 +125,7 @@ fn decode_property(node: Pair<'_, Rule>) -> Property {
                 // No escapes at this point.
                 let text = pair.as_str();
                 // Remove the quotes.
-                let text = &text[1..text.len()-1];
+                let text = &text[1..text.len() - 1];
                 value.push(Value::String(text.to_string()));
             }
             Rule::bytes => {
@@ -132,7 +134,10 @@ fn decode_property(node: Pair<'_, Rule>) -> Property {
             r => panic!("rule: {:?}", r),
         }
     }
-    Property { name: name.unwrap(), value }
+    Property {
+        name: name.unwrap(),
+        value,
+    }
 }
 
 fn decode_words<'i>(node: Pair<'i, Rule>) -> Vec<Word> {
@@ -205,7 +210,7 @@ impl<'a, 'b> LazyName<'a, 'b> {
                     name: "/".to_string(),
                     path: "/".to_string(),
                     ord,
-                })
+                }),
             }
         } else {
             LazyName {
@@ -232,11 +237,7 @@ impl<'a, 'b> LazyName<'a, 'b> {
         path.push_str(&name);
         // println!("node: {:?}", path);
         let ord = self.ords.0[&path];
-        self.info = Some(Info {
-            name,
-            path,
-            ord,
-        });
+        self.info = Some(Info { name, path, ord });
     }
 
     fn path_ref(&self) -> &str {

zephyr-build/src/lib.rs

@@ -11,9 +11,9 @@
 // This builds a program that is run on the compilation host before the code is compiled.  It can
 // output configuration settings that affect the compilation.
 
-use std::io::{BufRead, BufReader, Write};
 use std::env;
 use std::fs::File;
+use std::io::{BufRead, BufReader, Write};
 use std::path::Path;
 use std::process::{Command, Stdio};
 
@@ -37,7 +37,7 @@ pub fn export_bool_kconfig() {
 
     let file = File::open(&dotconfig).expect("Unable to open dotconfig");
     for line in BufReader::new(file).lines() {
-        let line =  line.expect("reading line from dotconfig");
+        let line = line.expect("reading line from dotconfig");
         if let Some(caps) = config_y.captures(&line) {
             println!("cargo:rustc-cfg={}", &caps[1]);
         }
@@ -66,25 +66,27 @@ pub fn build_kconfig_mod() {
         let line = line.expect("reading line from dotconfig");
         if let Some(caps) = config_hex.captures(&line) {
             writeln!(&mut f, "#[allow(dead_code)]").unwrap();
-            writeln!(&mut f, "pub const {}: usize = {};",
-                &caps[1], &caps[2]).unwrap();
+            writeln!(&mut f, "pub const {}: usize = {};", &caps[1], &caps[2]).unwrap();
         } else if let Some(caps) = config_int.captures(&line) {
             writeln!(&mut f, "#[allow(dead_code)]").unwrap();
-            writeln!(&mut f, "pub const {}: isize = {};",
-                &caps[1], &caps[2]).unwrap();
+            writeln!(&mut f, "pub const {}: isize = {};", &caps[1], &caps[2]).unwrap();
         } else if let Some(caps) = config_str.captures(&line) {
             writeln!(&mut f, "#[allow(dead_code)]").unwrap();
-            writeln!(&mut f, "pub const {}: &'static str = {};",
-                &caps[1], &caps[2]).unwrap();
+            writeln!(
+                &mut f,
+                "pub const {}: &'static str = {};",
+                &caps[1], &caps[2]
+            )
+            .unwrap();
         }
     }
 }
 
 /// Parse the finalized DTS file, generating the Rust devicetree file.
 fn import_dt() -> DeviceTree {
     let zephyr_dts = env::var("ZEPHYR_DTS").expect("ZEPHYR_DTS must be set");
-    let gen_include = env::var("BINARY_DIR_INCLUDE_GENERATED")
-        .expect("BINARY_DIR_INCLUDE_GENERATED must be set");
+    let gen_include =
+        env::var("BINARY_DIR_INCLUDE_GENERATED").expect("BINARY_DIR_INCLUDE_GENERATED must be set");
 
     let generated = format!("{}/devicetree_generated.h", gen_include);
     DeviceTree::new(&zephyr_dts, generated)
@@ -138,10 +140,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()
-    {
+    match Command::new("rustfmt").arg("--version").status() {
         Ok(st) if st.success() => true,
         _ => false,
     }
@@ -159,7 +158,10 @@ fn write_formatted(file: File, tokens: TokenStream) {
         .expect("Failed to run rustfmt");
     // TODO: Handle the above failing.
 
-    let mut stdin = rustfmt.stdin.as_ref().expect("Stdin should have been opened by spawn");
+    let mut stdin = rustfmt
+        .stdin
+        .as_ref()
+        .expect("Stdin should have been opened by spawn");
     writeln!(stdin, "{}", tokens).expect("Writing to rustfmt");
 
     match rustfmt.wait() {