Merge #638

638: inline variables in format && to_xx_case_ident && field_arrays r=therealprof a=burrbull

r? `@Emilgardis` 

Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

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(())
 }

ci/svd2rust-regress/src/tests.rs

@@ -1,4 +1,5 @@
 use inflections::Inflect;
+use std::borrow::Cow;
 
 #[derive(Debug, PartialEq)]
 pub enum Architecture {
@@ -68,7 +69,9 @@ impl TestCase {
     }
 
     pub fn name(&self) -> String {
-        format!("{:?}-{}", self.mfgr, self.chip.replace(".", "_")).to_sanitized_snake_case()
+        format!("{:?}-{}", self.mfgr, self.chip.replace(".", "_"))
+            .to_sanitized_snake_case()
+            .into()
     }
 }
 
@@ -80,95 +83,52 @@ use self::RunWhen::*;
 /// that are not valid in Rust ident
 const BLACKLIST_CHARS: &[char] = &['(', ')', '[', ']'];
 
-/// Lovingly stolen from `svd2rust`. Probably could be `Cow`
-pub trait ToSanitizedSnakeCase {
-    fn to_sanitized_snake_case(&self) -> String;
+/// Lovingly stolen from `svd2rust`
+pub trait ToSanitizedCase {
+    fn to_sanitized_not_keyword_snake_case(&self) -> Cow<str>;
+    fn to_sanitized_snake_case(&self) -> Cow<str> {
+        let s = self.to_sanitized_not_keyword_snake_case();
+        sanitize_keyword(s)
+    }
 }
 
-impl ToSanitizedSnakeCase for str {
-    fn to_sanitized_snake_case(&self) -> String {
-        macro_rules! keywords {
-            ($s:expr, $($kw:ident),+,) => {
-                String::from(match &$s.to_lowercase()[..] {
-                    $(stringify!($kw) => concat!(stringify!($kw), "_")),+,
-                    _ => return String::from($s.to_snake_case())
-                })
-            }
-        }
+impl ToSanitizedCase for str {
+    fn to_sanitized_not_keyword_snake_case(&self) -> Cow<str> {
+        const INTERNALS: [&str; 4] = ["set_bit", "clear_bit", "bit", "bits"];
 
         let s = self.replace(BLACKLIST_CHARS, "");
-
         match s.chars().next().unwrap_or('\0') {
             '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => {
-                format!("_{}", s.to_snake_case())
+                format!("_{}", s.to_snake_case()).into()
             }
             _ => {
-                keywords! {
-                    s,
-                    abstract,
-                    alignof,
-                    as,
-                    r#async,
-                    r#await,
-                    become,
-                    box,
-                    break,
-                    const,
-                    continue,
-                    crate,
-                    do,
-                    else,
-                    enum,
-                    extern,
-                    false,
-                    final,
-                    fn,
-                    for,
-                    if,
-                    impl,
-                    in,
-                    let,
-                    loop,
-                    macro,
-                    match,
-                    mod,
-                    move,
-                    mut,
-                    offsetof,
-                    override,
-                    priv,
-                    proc,
-                    pub,
-                    pure,
-                    ref,
-                    return,
-                    self,
-                    sizeof,
-                    static,
-                    struct,
-                    super,
-                    trait,
-                    true,
-                    r#try,
-                    type,
-                    typeof,
-                    unsafe,
-                    unsized,
-                    use,
-                    virtual,
-                    where,
-                    while,
-                    yield,
-                    set_bit,
-                    clear_bit,
-                    bit,
-                    bits,
+                let s = Cow::from(s.to_snake_case());
+                if INTERNALS.contains(&s.as_ref()) {
+                    s + "_"
+                } else {
+                    s
                 }
             }
         }
     }
 }
 
+pub fn sanitize_keyword(sc: Cow<str>) -> Cow<str> {
+    const KEYWORDS: [&str; 55] = [
+        "abstract", "alignof", "as", "async", "await", "become", "box", "break", "const",
+        "continue", "crate", "do", "dyn", "else", "enum", "extern", "false", "final", "fn", "for",
+        "if", "impl", "in", "let", "loop", "macro", "match", "mod", "move", "mut", "offsetof",
+        "override", "priv", "proc", "pub", "pure", "ref", "return", "self", "sizeof", "static",
+        "struct", "super", "trait", "true", "try", "type", "typeof", "unsafe", "unsized", "use",
+        "virtual", "where", "while", "yield",
+    ];
+    if KEYWORDS.contains(&sc.as_ref()) {
+        sc + "_"
+    } else {
+        sc
+    }
+}
+
 // NOTE: All chip names must be unique!
 pub const TESTS: &[&TestCase] = &[
     // BAD-SVD missing resetValue

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);