Merge pull request #120 from stm32-rs/fmt

formatted strings

Author: burrbull

README.md

@@ -34,7 +34,7 @@ more information on creating patches.
 
 ## Getting Started with Rust version
 
-This crate is guaranteed to compile on stable Rust 1.46.0 and up. To install:
+This crate is guaranteed to compile on stable Rust 1.58.0 and up. To install:
 
 ```bash
 $ cargo install svdtools

src/common/str_utils.rs

@@ -16,9 +16,9 @@ pub fn get_description(opt_str: &Option<String>) -> String {
 
 /// Make everything uppercase except first two character, which should be "0x"
 pub fn format_address(hex_address: u64) -> String {
-    let addr = format! {"{:x}", hex_address};
+    let addr = format! {"{hex_address:x}"};
     let addr = addr.to_uppercase();
-    format!("0x{}", addr)
+    format!("0x{addr}")
 }
 
 #[cfg(test)]

src/common/svd_utils.rs

@@ -21,6 +21,6 @@ pub fn access_with_brace(access: Option<Access>) -> String {
     if access.is_empty() {
         access.to_string()
     } else {
-        format!(" ({})", access)
+        format!(" ({access})")
     }
 }

src/makedeps/makedeps_cli.rs

@@ -45,7 +45,7 @@ pub fn makedeps(yaml_file: &Path, deps_file: &Path) -> Result<()> {
             write_file(deps_file, deps)?;
             Ok(())
         }
-        _ => Err(anyhow!("Incorrect yaml {:?}", yaml_file)),
+        _ => Err(anyhow!("Incorrect yaml {yaml_file:?}")),
     }
 }
 

src/mmap/mmap_cli.rs

@@ -11,7 +11,7 @@ pub fn parse_device(svd_file: &Path) -> Result<()> {
     match get_text(&mut file) {
         Err(e) => {
             let path_str = svd_file.display();
-            Err(e).with_context(|| format!("Parsing {}", path_str))
+            Err(e).with_context(|| format!("Parsing {path_str}"))
         }
         Ok(text) => {
             println!("{}", text);
@@ -71,8 +71,8 @@ fn get_interrupts(peripheral: &Peripheral, mmap: &mut Vec<String>) {
     for i in &peripheral.interrupt {
         let description = str_utils::get_description(&i.description);
         let text = format!(
-            "INTERRUPT {:03}: {} ({}): {}",
-            i.value, i.name, peripheral.name, description
+            "INTERRUPT {:03}: {} ({}): {description}",
+            i.value, i.name, peripheral.name
         );
         mmap.push(text);
     }
@@ -95,10 +95,7 @@ fn get_registers(
                         Register::Single(r) => {
                             let addr = str_utils::format_address(first_addr);
                             let rname = r.name.to_string() + suffix;
-                            let text = format!(
-                                "{} B  REGISTER {}{}: {}",
-                                addr, rname, access, description
-                            );
+                            let text = format!("{addr} B  REGISTER {rname}{access}: {description}");
                             mmap.push(text);
                             get_fields(r, &addr, mmap);
                         }
@@ -109,10 +106,8 @@ fn get_registers(
                                 );
                                 let rname = r.name.replace("%s", &idx);
                                 let description = description.replace("%s", &idx);
-                                let text = format!(
-                                    "{} B  REGISTER {}{}: {}",
-                                    addr, rname, access, description
-                                );
+                                let text =
+                                    format!("{addr} B  REGISTER {rname}{access}: {description}");
                                 mmap.push(text);
                                 get_fields(r, &addr, mmap);
                             }
@@ -125,7 +120,8 @@ fn get_registers(
                     match c {
                         Cluster::Single(c) => {
                             let addr = str_utils::format_address(first_addr);
-                            let text = format!("{} B  CLUSTER {}: {}", addr, c.name, description);
+                            let cname = &c.name;
+                            let text = format!("{addr} B  CLUSTER {cname}: {description}");
                             mmap.push(text);
                             get_registers(first_addr, Some(&c.children), "", mmap);
                         }
@@ -135,8 +131,7 @@ fn get_registers(
                                 let addr = str_utils::format_address(caddr);
                                 let cname = c.name.replace("%s", &idx);
                                 let description = description.replace("%s", &idx);
-                                let text =
-                                    format!("{} B  CLUSTER {}: {}", addr, cname, description);
+                                let text = format!("{addr} B  CLUSTER {cname}: {description}");
                                 mmap.push(text);
                                 get_registers(caddr, Some(&c.children), &idx, mmap);
                             }
@@ -156,19 +151,20 @@ fn get_fields(register: &RegisterInfo, addr: &str, mmap: &mut Vec<String>) {
             match f {
                 Field::Single(f) => {
                     let bit_offset = f.bit_range.offset;
+                    let bit_width = f.bit_range.width;
+                    let fname = &f.name;
                     let text = format!(
-                        "{} C   FIELD {:02}w{:02} {}{}: {}",
-                        addr, bit_offset, f.bit_range.width, f.name, access, description
+                        "{addr} C   FIELD {bit_offset:02}w{bit_width:02} {fname}{access}: {description}"
                     );
                     mmap.push(text);
                 }
                 Field::Array(f, d) => {
                     for (i, idx) in d.indexes().enumerate() {
                         let bit_offset = f.bit_range.offset + (i as u32) * d.dim_increment;
+                        let bit_width = f.bit_range.width;
                         let fname = f.name.replace("%s", &idx);
                         let text = format!(
-                            "{} C   FIELD {:02}w{:02} {}{}: {}",
-                            addr, bit_offset, f.bit_range.width, fname, access, description
+                            "{addr} C   FIELD {bit_offset:02}w{bit_width:02} {fname}{access}: {description}"
                         );
                         mmap.push(text);
                     }

src/patch/device.rs

@@ -66,7 +66,7 @@ impl DeviceExt for Device {
         // Handle any deletions
         for pspec in device.str_vec_iter("_delete") {
             self.delete_peripheral(pspec)
-                .with_context(|| format!("Deleting peripheral matched to `{}`", pspec))?;
+                .with_context(|| format!("Deleting peripheral matched to `{pspec}`"))?;
         }
 
         // Handle any copied peripherals
@@ -77,7 +77,7 @@ impl DeviceExt for Device {
                 val.hash()?,
                 Path::new(device.get_str("_path")?.unwrap_or(".")),
             )
-            .with_context(|| format!("Copying peripheral `{}`", pname))?;
+            .with_context(|| format!("Copying peripheral `{pname}`"))?;
         }
 
         // Handle any modifications
@@ -92,7 +92,7 @@ impl DeviceExt for Device {
                         let pspec = pspec.str()?;
                         self.modify_peripheral(pspec, pmod.hash()?)
                             .with_context(|| {
-                                format!("Modifying peripherals matched to `{}`", pspec)
+                                format!("Modifying peripherals matched to `{pspec}`")
                             })?;
                     }
                 }
@@ -115,40 +115,37 @@ impl DeviceExt for Device {
 
                 _ => self
                     .modify_peripheral(key, val.hash()?)
-                    .with_context(|| format!("Modifying peripherals matched to `{}`", key))?,
+                    .with_context(|| format!("Modifying peripherals matched to `{key}`"))?,
             }
         }
 
         // Handle field clearing
         for pspec in device.str_vec_iter("_clear_fields") {
             self.clear_fields(pspec).with_context(|| {
-                format!(
-                    "Clearing contents of fields in peripherals matched to `{}` ",
-                    pspec
-                )
+                format!("Clearing contents of fields in peripherals matched to `{pspec}` ")
             })?;
         }
 
         // Handle any new peripherals (!)
         for (pname, padd) in device.hash_iter("_add") {
             let pname = pname.str()?;
             self.add_peripheral(pname, padd.hash()?)
-                .with_context(|| format!("Adding peripheral `{}`", pname))?;
+                .with_context(|| format!("Adding peripheral `{pname}`"))?;
         }
 
         // Handle any derived peripherals
         for (pname, pderive) in device.hash_iter("_derive") {
             let pname = pname.str()?;
             self.derive_peripheral(pname, pderive)
-                .with_context(|| format!("Deriving peripheral `{}` from `{:?}`", pname, pderive))?;
+                .with_context(|| format!("Deriving peripheral `{pname}` from `{pderive:?}`"))?;
         }
 
         // Handle any rebased peripherals
         for (pname, pold) in device.hash_iter("_rebase") {
             let pname = pname.str()?;
             let pold = pold.str()?;
             self.rebase_peripheral(pname, pold)
-                .with_context(|| format!("Rebasing peripheral from `{}` to `{}`", pold, pname))?;
+                .with_context(|| format!("Rebasing peripheral from `{pold}` to `{pname}`"))?;
         }
 
         // Now process all peripherals
@@ -157,7 +154,7 @@ impl DeviceExt for Device {
             if !periphspec.starts_with('_') {
                 //val["_path"] = device["_path"]; // TODO: check
                 self.process_peripheral(periphspec, val.hash()?, update_fields)
-                    .with_context(|| format!("According to `{}`", periphspec))?;
+                    .with_context(|| format!("According to `{periphspec}`"))?;
             }
         }
 
@@ -181,16 +178,16 @@ impl DeviceExt for Device {
                 let mut contents = String::new();
                 (&f).read_to_string(&mut contents).unwrap();
                 let filedev = svd_parser::parse(&contents)
-                    .with_context(|| format!("Parsing file {}", contents))?;
+                    .with_context(|| format!("Parsing file {contents}"))?;
                 filedev
                     .get_peripheral(pcopyname)
-                    .ok_or_else(|| anyhow!("peripheral {} not found", pcopyname))?
+                    .ok_or_else(|| anyhow!("peripheral {pcopyname} not found"))?
                     .clone()
             }
             [pcopyname] => {
                 let mut new = self
                     .get_peripheral(pcopyname)
-                    .ok_or_else(|| anyhow!("peripheral {} not found", pcopyname))?
+                    .ok_or_else(|| anyhow!("peripheral {pcopyname} not found"))?
                     .clone();
                 // When copying from a peripheral in the same file, remove any interrupts.
                 new.interrupt = Vec::new();
@@ -265,7 +262,7 @@ impl DeviceExt for Device {
 
     fn add_peripheral(&mut self, pname: &str, padd: &Hash) -> PatchResult {
         if self.get_peripheral(pname).is_some() {
-            return Err(anyhow!("device already has a peripheral {}", pname));
+            return Err(anyhow!("device already has a peripheral {pname}"));
         }
 
         self.peripherals.push(
@@ -300,7 +297,7 @@ impl DeviceExt for Device {
 
         if !pderive.contains('.') {
             self.get_peripheral(pderive)
-                .ok_or_else(|| anyhow!("peripheral {} not found", pderive))?;
+                .ok_or_else(|| anyhow!("peripheral {pderive} not found"))?;
         }
 
         match self.get_mut_peripheral(pname) {
@@ -324,7 +321,7 @@ impl DeviceExt for Device {
     fn rebase_peripheral(&mut self, pnew: &str, pold: &str) -> PatchResult {
         let old = self
             .get_mut_peripheral(pold)
-            .ok_or_else(|| anyhow!("peripheral {} not found", pold))?;
+            .ok_or_else(|| anyhow!("peripheral {pold} not found"))?;
         let mut d = std::mem::replace(
             old,
             PeripheralInfo::builder()
@@ -341,7 +338,7 @@ impl DeviceExt for Device {
         );
         let new = self
             .get_mut_peripheral(pnew)
-            .ok_or_else(|| anyhow!("peripheral {} not found", pnew))?;
+            .ok_or_else(|| anyhow!("peripheral {pnew} not found"))?;
         d.name = new.name.clone();
         d.base_address = new.base_address;
         d.interrupt = new.interrupt.clone();
@@ -380,7 +377,7 @@ impl DeviceExt for Device {
                 .with_context(|| format!("Processing peripheral `{}`", ptag.name))?;
         }
         if pcount == 0 {
-            Err(anyhow!("Could not find `{}`", pspec))
+            Err(anyhow!("Could not find `{pspec}`"))
         } else {
             Ok(())
         }

src/patch/mod.rs

@@ -82,7 +82,7 @@ pub fn yaml_includes(parent: &mut Hash) -> Result<Vec<PathBuf>> {
     for relpath in inc {
         let relpath = relpath.as_str().unwrap();
         let path = abspath(&self_path, Path::new(relpath))
-            .with_context(|| anyhow!("Opening file \"{}\" from file {:?}", relpath, self_path))?;
+            .with_context(|| anyhow!("Opening file \"{relpath}\" from file {self_path:?}"))?;
         if included.contains(&path) {
             continue;
         }
@@ -251,10 +251,7 @@ fn make_ev_array(values: &Hash) -> Result<EnumeratedValuesBuilder> {
             let vd = vd.vec()?;
             let value = vd[0].i64()? as u64;
             let description = vd.get(1).and_then(Yaml::as_str).ok_or_else(|| {
-                anyhow!(
-                    "enumeratedValue can't have empty description for value {}",
-                    value
-                )
+                anyhow!("enumeratedValue can't have empty description for value {value}")
             })?;
             use std::collections::btree_map::Entry;
             match h.entry(value) {