inline varibles in format

Author: burrbull

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Use inlined variables in `format!` (Rust 1.58)
 - Refactor `periperal.rs`
 - use `svd_parser::expand::Index` for derive
 - Generated enum names now consider `name` field in `enumeratedValues`

ci/svd2rust-regress/src/main.rs

@@ -94,15 +94,15 @@ fn validate_architecture(s: String) -> Result<(), String> {
     if tests::TESTS.iter().any(|t| format!("{:?}", t.arch) == s) {
         Ok(())
     } else {
-        Err(format!("Architecture `{}` is not a valid value", s))
+        Err(format!("Architecture `{s}` is not a valid value"))
     }
 }
 
 fn validate_manufacturer(s: String) -> Result<(), String> {
     if tests::TESTS.iter().any(|t| format!("{:?}", t.mfgr) == s) {
         Ok(())
     } else {
-        Err(format!("Manufacturer `{}` is not a valid value", s))
+        Err(format!("Manufacturer `{s}` is not a valid value"))
     }
 }
 

ci/svd2rust-regress/src/svd_test.rs

@@ -28,10 +28,10 @@ fn path_helper_base(base: &PathBuf, input: &[&str]) -> PathBuf {
 
 /// Create and write to file
 fn file_helper(payload: &str, path: &PathBuf) -> Result<()> {
-    let mut f = File::create(path).chain_err(|| format!("Failed to create {:?}", path))?;
+    let mut f = File::create(path).chain_err(|| format!("Failed to create {path:?}"))?;
 
     f.write_all(payload.as_bytes())
-        .chain_err(|| format!("Failed to write to {:?}", path))?;
+        .chain_err(|| format!("Failed to write to {path:?}"))?;
 
     Ok(())
 }

src/generate/device.rs

@@ -30,7 +30,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
 
     let doc = format!(
         "Peripheral access API for {0} microcontrollers \
-         (generated using svd2rust v{1}{2})\n\n\
+         (generated using svd2rust v{1}{commit_info})\n\n\
          You can find an overview of the generated API [here].\n\n\
          API features to be included in the [next] svd2rust \
          release can be generated by cloning the svd2rust [repository], \
@@ -40,7 +40,6 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
          [repository]: https://github.com/rust-embedded/svd2rust",
         d.name.to_uppercase(),
         env!("CARGO_PKG_VERSION"),
-        commit_info
     );
 
     if config.target == Target::Msp430 {
@@ -212,7 +211,9 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
     )?);
 
     for p in &d.peripherals {
-        if config.target == Target::CortexM && core_peripherals.contains(&&*p.name.to_uppercase()) {
+        if config.target == Target::CortexM
+            && core_peripherals.contains(&p.name.to_uppercase().as_ref())
+        {
             // Core peripherals are handled above
             continue;
         }
@@ -224,15 +225,11 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                 let descrip = p.description.as_deref().unwrap_or("No description");
                 let group_name = p.group_name.as_deref().unwrap_or("No group name");
                 let mut context_string = format!(
-                    "Rendering error at peripheral\nName: {}\nDescription: {}\nGroup: {}",
-                    p.name, descrip, group_name
+                    "Rendering error at peripheral\nName: {}\nDescription: {descrip}\nGroup: {group_name}",
+                    p.name
                 );
-                if p.derived_from.is_some() {
-                    context_string = format!(
-                        "{}\nDerived from: {}",
-                        context_string,
-                        p.derived_from.as_deref().unwrap()
-                    );
+                if let Some(dname) = p.derived_from.as_ref() {
+                    context_string = format!("{context_string}\nDerived from: {dname}");
                 }
                 let mut e = Err(e);
                 e = e.with_context(|| context_string);

src/generate/peripheral.rs

@@ -415,8 +415,8 @@ impl FieldRegions {
             .for_each(|r| {
                 let new_ident = r.shortest_ident();
                 warn!(
-                    "Found type name conflict with region {:?}, renamed to {:?}",
-                    r.ident, new_ident
+                    "Found type name conflict with region {:?}, renamed to {new_ident:?}",
+                    r.ident
                 );
                 r.ident = new_ident;
             });
@@ -425,19 +425,12 @@ impl FieldRegions {
 }
 
 fn make_comment(size: u32, offset: u32, description: &str) -> String {
+    let desc = util::escape_brackets(&util::respace(description));
     if size > 32 {
-        format!(
-            "0x{:02x}..0x{:02x} - {}",
-            offset,
-            offset + size / 8,
-            util::escape_brackets(&util::respace(description)),
-        )
+        let end = offset + size / 8;
+        format!("0x{offset:02x}..0x{end:02x} - {desc}")
     } else {
-        format!(
-            "0x{:02x} - {}",
-            offset,
-            util::escape_brackets(&util::respace(description)),
-        )
+        format!("0x{offset:02x} - {desc}")
     }
 }
 
@@ -472,7 +465,7 @@ fn register_or_cluster_block(
         // Check if we need padding
         let pad = region.offset - last_end;
         if pad != 0 {
-            let name = Ident::new(&format!("_reserved{}", i), span);
+            let name = Ident::new(&format!("_reserved{i}"), span);
             let pad = util::hex(pad as u64);
             rbfs.extend(quote! {
                 #name : [u8; #pad],
@@ -529,8 +522,7 @@ fn register_or_cluster_block(
             // nice identifier.
             let name = Ident::new(
                 &format!(
-                    "_reserved_{}_{}",
-                    i,
+                    "_reserved_{i}_{}",
                     region
                         .compute_ident()
                         .unwrap_or_else(|| format!("{}_{}", region.offset, region.end))
@@ -988,14 +980,14 @@ fn convert_svd_register(
         Register::Single(info) => {
             let info_name = info.fullname(ignore_group);
             let ty = name_to_wrapped_ty(&info_name, name)
-                .with_context(|| format!("Error converting register name {}", info_name))?;
+                .with_context(|| format!("Error converting register name {info_name}"))?;
             new_syn_field(&info_name.to_sanitized_snake_case(), ty)
         }
         Register::Array(info, array_info) => {
             let info_name = info.fullname(ignore_group);
             let nb_name = util::replace_suffix(&info_name, "");
             let ty = name_to_wrapped_ty(&nb_name, name)
-                .with_context(|| format!("Error converting register name {}", nb_name))?;
+                .with_context(|| format!("Error converting register name {nb_name}"))?;
             let array_ty = new_syn_array(ty, array_info.dim)?;
 
             new_syn_field(&nb_name.to_sanitized_snake_case(), array_ty)
@@ -1013,8 +1005,7 @@ fn array_proxy(
     let tys = name_to_ty_str(&ty_name, name);
 
     let ap_path = parse_str::<syn::TypePath>(&format!(
-        "crate::ArrayProxy<{}, {}, {}>",
-        tys,
+        "crate::ArrayProxy<{tys}, {}, {}>",
         array_info.dim,
         util::hex(array_info.dim_increment as u64)
     ))?;
@@ -1139,5 +1130,5 @@ fn name_to_wrapped_ty(name: &str, ns: Option<&str>) -> Result<syn::Type> {
     parse_str::<syn::TypePath>(&ident)
         .map(syn::Type::Path)
         .map_err(anyhow::Error::from)
-        .with_context(|| format!("Determining syn::TypePath from ident \"{}\" failed", ident))
+        .with_context(|| format!("Determining syn::TypePath from ident \"{ident}\" failed"))
 }

src/generate/register.rs

@@ -229,13 +229,11 @@ pub fn render(
         .iter()
         .map(|s| format!("[`{0}`](crate::generic::Reg::{0})", s))
         .collect::<Vec<_>>();
-    let mut doc = format!("{}\n\nThis register you can {}. See [API](https://docs.rs/svd2rust/#read--modify--write-api).",
-                        &description, methods.join(", "));
+    let mut doc = format!("{description}\n\nThis register you can {}. See [API](https://docs.rs/svd2rust/#read--modify--write-api).", methods.join(", "));
 
     if name_snake_case != "cfg" {
         doc += format!(
-            "\n\nFor information about available fields see [{0}](index.html) module",
-            &name_snake_case
+            "\n\nFor information about available fields see [{name_snake_case}](index.html) module"
         )
         .as_str();
     }
@@ -251,10 +249,8 @@ pub fn render(
         }
     }
 
-    let alias_doc = format!(
-        "{} register accessor: an alias for `Reg<{}>`",
-        name, name_constant_case_spec,
-    );
+    let alias_doc =
+        format!("{name} register accessor: an alias for `Reg<{name_constant_case_spec}>`");
     out.extend(quote! {
         #[doc = #alias_doc]
         pub type #name_constant_case = crate::Reg<#name_snake_case::#name_constant_case_spec>;
@@ -269,10 +265,7 @@ pub fn render(
     });
 
     if can_read {
-        let doc = format!(
-            "`read()` method returns [{0}::R](R) reader structure",
-            &name_snake_case
-        );
+        let doc = format!("`read()` method returns [{name_snake_case}::R](R) reader structure",);
         mod_items.extend(quote! {
             #[doc = #doc]
             impl crate::Readable for #name_constant_case_spec {
@@ -281,10 +274,8 @@ pub fn render(
         });
     }
     if can_write {
-        let doc = format!(
-            "`write(|w| ..)` method takes [{0}::W](W) writer structure",
-            &name_snake_case
-        );
+        let doc =
+            format!("`write(|w| ..)` method takes [{name_snake_case}::W](W) writer structure",);
         mod_items.extend(quote! {
             #[doc = #doc]
             impl crate::Writable for #name_constant_case_spec {
@@ -293,7 +284,7 @@ pub fn render(
         });
     }
     if let Some(rv) = properties.reset_value.map(util::hex) {
-        let doc = format!("`reset()` method sets {} to value {}", register.name, &rv);
+        let doc = format!("`reset()` method sets {} to value {rv}", register.name);
         mod_items.extend(quote! {
             #[doc = #doc]
             impl crate::Resettable for #name_constant_case_spec {
@@ -416,7 +407,7 @@ pub fn fields(
                     0
                 };
                 let suffixes: Vec<_> = de.indexes().collect();
-                let suffixes_str = format!("({}-{})", first, first + de.dim - 1);
+                let suffixes_str = format!("({first}-{})", first + de.dim - 1);
                 Some((first, de.dim, de.dim_increment, suffixes, suffixes_str))
             }
             Field::Single(_) => {
@@ -453,12 +444,11 @@ pub fn fields(
             // the suffix string from field name is removed in brief description.
             let field_reader_brief = if let Some((_, _, _, _, suffixes_str)) = &field_dim {
                 format!(
-                    "Fields `{}` reader - {}",
+                    "Fields `{}` reader - {description}",
                     util::replace_suffix(&f.name, suffixes_str),
-                    description,
                 )
             } else {
-                format!("Field `{}` reader - {}", f.name, description)
+                format!("Field `{}` reader - {description}", f.name)
             };
 
             // get the type of value structure. It can be generated from either name field
@@ -468,11 +458,11 @@ pub fn fields(
                 if let Some(enum_name) = &evs.name {
                     let enum_name_constant_case = enum_name.to_sanitized_constant_case();
                     let enum_value_read_ty =
-                        Ident::new(&format!("{}_A", enum_name_constant_case), span);
+                        Ident::new(&format!("{enum_name_constant_case}_A"), span);
                     enum_value_read_ty
                 } else {
                     let derived_field_value_read_ty =
-                        Ident::new(&format!("{}_A", name_constant_case), span);
+                        Ident::new(&format!("{name_constant_case}_A"), span);
                     derived_field_value_read_ty
                 }
             } else {
@@ -604,14 +594,14 @@ pub fn fields(
 
                         let is_variant = Ident::new(
                             &if sc.to_string().starts_with('_') {
-                                format!("is{}", sc)
+                                format!("is{sc}")
                             } else {
-                                format!("is_{}", sc)
+                                format!("is_{sc}")
                             },
                             span,
                         );
 
-                        let doc = format!("Checks if the value of the field is `{}`", pc);
+                        let doc = format!("Checks if the value of the field is `{pc}`");
                         enum_items.extend(quote! {
                             #[doc = #doc]
                             #inline
@@ -735,12 +725,11 @@ pub fn fields(
             // gets a brief of write proxy
             let field_writer_brief = if let Some((_, _, _, _, suffixes_str)) = &field_dim {
                 format!(
-                    "Fields `{}` writer - {}",
+                    "Fields `{}` writer - {description}",
                     util::replace_suffix(&f.name, suffixes_str),
-                    description,
                 )
             } else {
-                format!("Field `{}` writer - {}", f.name, description)
+                format!("Field `{}` writer - {description}", f.name)
             };
 
             let value_write_ty =
@@ -754,11 +743,11 @@ pub fn fields(
                     if let Some(enum_name) = &evs.name {
                         let enum_name_constant_case = enum_name.to_sanitized_constant_case();
                         let enum_value_write_ty =
-                            Ident::new(&format!("{}_{}", enum_name_constant_case, ty_suffix), span);
+                            Ident::new(&format!("{enum_name_constant_case}_{ty_suffix}"), span);
                         enum_value_write_ty
                     } else {
                         let derived_field_value_write_ty =
-                            Ident::new(&format!("{}_{}", name_constant_case, ty_suffix), span);
+                            Ident::new(&format!("{name_constant_case}_{ty_suffix}"), span);
                         derived_field_value_write_ty
                     }
                 } else {
@@ -1007,7 +996,7 @@ impl Variant {
                     doc: ev
                         .description
                         .clone()
-                        .unwrap_or_else(|| format!("`{:b}`", value)),
+                        .unwrap_or_else(|| format!("`{value:b}`")),
                     pc: Ident::new(
                         &(if pc {
                             ev.name.to_sanitized_pascal_case()
@@ -1039,9 +1028,9 @@ fn add_with_no_variants(
     };
 
     let desc = if let Some(rv) = reset_value {
-        format!("{}\n\nValue on reset: {}", desc, rv)
+        format!("{desc}\n\nValue on reset: {rv}")
     } else {
-        desc.to_owned()
+        desc.to_string()
     };
 
     mod_items.extend(quote! {
@@ -1085,9 +1074,9 @@ fn add_from_variants(
     }
 
     let desc = if let Some(rv) = reset_value {
-        format!("{}\n\nValue on reset: {}", desc, rv)
+        format!("{desc}\n\nValue on reset: {rv}")
     } else {
-        desc.to_owned()
+        desc.to_string()
     };
 
     mod_items.extend(quote! {
@@ -1140,9 +1129,9 @@ fn calculate_offset(
 
 fn description_with_bits(description: &str, offset: u64, width: u32) -> String {
     let mut res = if width == 1 {
-        format!("Bit {}", offset)
+        format!("Bit {offset}")
     } else {
-        format!("Bits {}:{}", offset, offset + width as u64 - 1)
+        format!("Bits {offset}:{}", offset + width as u64 - 1)
     };
     if !description.is_empty() {
         res.push_str(" - ");

src/main.rs

@@ -232,7 +232,7 @@ fn run() -> Result<()> {
     if feature_group {
         let group_names: Vec<String> = group_names(&device)
             .iter()
-            .map(|s| format!("{} = []\n", s))
+            .map(|s| format!("{s} = []\n"))
             .collect();
         write!(
             File::create(path.join("features.toml"))?,
@@ -275,7 +275,7 @@ fn setup_logging<'a>(getter: &'a impl clap_conf::Getter<'a, String>) {
 
 fn main() {
     if let Err(ref e) = run() {
-        error!("{:?}", e);
+        error!("{e:?}");
 
         process::exit(1);
     }