stdarch-gen-arm: Modernization of the coding style

It modernizes the coding style of the crate stdarch-gen-arm by fixing
Clippy warnings (except clippy::{collapsible_if,obfuscated_if_else} that
might make the program look worse as a result of "fixing" warnings).

Clippy: rust version 1.89.0-nightly (6f6971078 2025-05-28)
Number of Fixed Warnings: 84/84
Note:
Rust Analyzer double counts one of the Clippy warnings so it reduces
85 warnings (as reported by the Rust Analyzer).

This commit also applies similar technique used to resolve Clippy
warnings but also simplifies identifier name formatting and makes
reading easier.

Confirmed that the exact same code will be generated.

Author: a4lg

crates/stdarch-gen-arm/src/big_endian.rs

@@ -38,7 +38,7 @@ fn create_array(lanes: u32) -> Option<String> {
         4 => Some("[3, 2, 1, 0]".to_string()),
         8 => Some("[7, 6, 5, 4, 3, 2, 1, 0]".to_string()),
         16 => Some("[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]".to_string()),
-        _ => panic!("Incorrect vector number of vector lanes: {}", lanes),
+        _ => panic!("Incorrect vector number of vector lanes: {lanes}"),
     }
 }
 
@@ -78,12 +78,7 @@ pub fn type_has_tuple(type_kind: &TypeKind) -> bool {
 }
 
 pub fn make_variable_mutable(variable_name: &str, type_kind: &TypeKind) -> Expression {
-    let mut_variable = format!(
-        "let mut {}: {} = {}",
-        variable_name,
-        type_kind.to_string(),
-        variable_name
-    );
+    let mut_variable = format!("let mut {variable_name}: {type_kind} = {variable_name}");
     let identifier_name = create_single_wild_string(&mut_variable);
     Expression::Identifier(identifier_name, IdentifierType::Symbol)
 }
@@ -114,9 +109,7 @@ fn create_shuffle_internal(
     };
 
     let lane_count = vector_type.lanes();
-    let Some(array_lanes) = create_array(lane_count) else {
-        return None;
-    };
+    let array_lanes = create_array(lane_count)?;
 
     let tuple_count = vector_type.tuple_size().map_or_else(|| 0, |t| t.to_int());
 
@@ -144,10 +137,7 @@ fn create_assigned_tuple_shuffle_call_fmt(
     array_lanes: &String,
 ) -> String {
     format!(
-        "{variable_name}.{idx} = unsafe {{ simd_shuffle!({variable_name}.{idx}, {variable_name}.{idx}, {array_lanes}) }};\n",
-        variable_name = variable_name,
-        idx = idx,
-        array_lanes = array_lanes
+        "{variable_name}.{idx} = unsafe {{ simd_shuffle!({variable_name}.{idx}, {variable_name}.{idx}, {array_lanes}) }};\n"
     )
 }
 
@@ -157,10 +147,7 @@ fn create_assigned_shuffle_call_fmt(
     array_lanes: &String,
 ) -> String {
     format!(
-        "let {variable_name}: {type_kind} = unsafe {{ simd_shuffle!({variable_name}, {variable_name}, {array_lanes}) }}",
-        type_kind = type_kind.to_string(),
-        variable_name = variable_name,
-        array_lanes = array_lanes
+        "let {variable_name}: {type_kind} = unsafe {{ simd_shuffle!({variable_name}, {variable_name}, {array_lanes}) }}"
     )
 }
 
@@ -169,11 +156,7 @@ fn create_shuffle_call_fmt(
     _type_kind: &TypeKind,
     array_lanes: &String,
 ) -> String {
-    format!(
-        "simd_shuffle!({variable_name}, {variable_name}, {array_lanes})",
-        variable_name = variable_name,
-        array_lanes = array_lanes
-    )
+    format!("simd_shuffle!({variable_name}, {variable_name}, {array_lanes})")
 }
 
 /// Create a `simd_shuffle!(<...>, [...])` call, where the output is stored

crates/stdarch-gen-arm/src/context.rs

@@ -1,6 +1,6 @@
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, usize};
+use std::collections::HashMap;
 
 use crate::{
     expression::Expression,
@@ -165,11 +165,12 @@ impl LocalContext {
                 .map_or_else(err, |ty| Ok((ty.size().parse::<i32>().unwrap()-1).to_string())),
             Wildcard::SizeInBytesLog2(idx) => self.input.typekind(*idx)
                 .map_or_else(err, |ty| Ok(ty.size_in_bytes_log2())),
-            Wildcard::NVariant if self.substitutions.get(wildcard).is_none() => Ok(String::new()),
+            Wildcard::NVariant if !self.substitutions.contains_key(wildcard) => Ok(String::new()),
             Wildcard::TypeKind(idx, opts) => {
                 self.input.typekind(*idx)
                     .map_or_else(err, |ty| {
                         let literal = if let Some(opts) = opts {
+                            #[allow(clippy::obfuscated_if_else)]
                             opts.contains(ty.base_type().map(|bt| *bt.kind()).ok_or_else(|| {
                                 format!("cannot retrieve a type literal out of {ty}")
                             })?)

crates/stdarch-gen-arm/src/expression.rs

@@ -56,7 +56,7 @@ impl FnCall {
         FnCall(Box::new(fn_ptr), arguments, Vec::new(), true).into()
     }
 
-    pub fn is_llvm_link_call(&self, llvm_link_name: &String) -> bool {
+    pub fn is_llvm_link_call(&self, llvm_link_name: &str) -> bool {
         self.is_expected_call(llvm_link_name)
     }
 
@@ -66,7 +66,7 @@ impl FnCall {
 
     pub fn is_expected_call(&self, fn_call_name: &str) -> bool {
         if let Expression::Identifier(fn_name, IdentifierType::Symbol) = self.0.as_ref() {
-            &fn_name.to_string() == fn_call_name
+            fn_name.to_string() == fn_call_name
         } else {
             false
         }
@@ -205,6 +205,7 @@ impl Expression {
             Self::FnCall(fn_call) => {
                 fn_call.build(intrinsic, ctx)?;
 
+                #[allow(clippy::collapsible_if)]
                 if let Some(llvm_link_name) = ctx.local.substitutions.get(&Wildcard::LLVMLink) {
                     if fn_call.is_llvm_link_call(llvm_link_name) {
                         *self = intrinsic
@@ -357,19 +358,15 @@ impl Expression {
                         false
                     }
                 }
-                _ => panic!("Badly defined function call: {:?}", fn_call),
+                _ => panic!("Badly defined function call: {fn_call:?}"),
             },
             _ => false,
         }
     }
 
     /// Determine if an espression is a LLVM binding
     pub fn is_llvm_link(&self) -> bool {
-        if let Expression::LLVMLink(_) = self {
-            true
-        } else {
-            false
-        }
+        matches!(self, Expression::LLVMLink(_))
     }
 }
 
@@ -508,7 +505,7 @@ impl ToTokens for Expression {
                 identifier
                     .to_string()
                     .parse::<TokenStream>()
-                    .expect(format!("invalid syntax: {:?}", self).as_str())
+                    .unwrap_or_else(|_| panic!("invalid syntax: {self:?}"))
                     .to_tokens(tokens);
             }
             Self::IntConstant(n) => tokens.append(Literal::i32_unsuffixed(*n)),

crates/stdarch-gen-arm/src/fn_suffix.rs

@@ -61,7 +61,7 @@ fn neon_get_base_and_char(ty: &VectorType) -> (u32, char, bool) {
         BaseType::Sized(BaseTypeKind::Int, size) => (*size, 's', *size * lanes == 128),
         BaseType::Sized(BaseTypeKind::UInt, size) => (*size, 'u', *size * lanes == 128),
         BaseType::Sized(BaseTypeKind::Poly, size) => (*size, 'p', *size * lanes == 128),
-        _ => panic!("Unhandled {:?}", ty),
+        _ => panic!("Unhandled {ty:?}"),
     }
 }
 
@@ -73,169 +73,92 @@ pub fn make_neon_suffix(type_kind: TypeKind, suffix_kind: SuffixKind) -> String
         TypeKind::Vector(ty) => {
             let tuple_size = ty.tuple_size().map_or(0, |t| t.to_int());
             let (base_size, prefix_char, requires_q) = neon_get_base_and_char(&ty);
+            let prefix_q = if requires_q { "q" } else { "" };
             let lanes = ty.lanes();
             match suffix_kind {
                 SuffixKind::Normal => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push('_');
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
+                    let mut str_suffix: String = format!("{prefix_q}_{prefix_char}{base_size}");
                     if tuple_size > 0 {
                         str_suffix.push_str("_x");
                         str_suffix.push_str(tuple_size.to_string().as_str());
                     }
-                    return str_suffix;
+                    str_suffix
                 }
                 SuffixKind::NSuffix => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push_str("_n_");
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
-                    return str_suffix;
+                    format!("{prefix_q}_n_{prefix_char}{base_size}")
                 }
 
-                SuffixKind::NoQ => format!("_{}{}", prefix_char, base_size),
-                SuffixKind::NoQNSuffix => format!("_n{}{}", prefix_char, base_size),
+                SuffixKind::NoQ => format!("_{prefix_char}{base_size}"),
+                SuffixKind::NoQNSuffix => format!("_n{prefix_char}{base_size}"),
 
                 SuffixKind::Unsigned => {
                     let t = type_kind.to_string();
                     if t.starts_with("u") {
                         return t;
                     }
-                    return format!("u{}", t);
+                    format!("u{t}")
                 }
                 SuffixKind::Lane => {
                     if lanes == 0 {
-                        panic!("type {} has no lanes!", type_kind.to_string())
+                        panic!("type {type_kind} has no lanes!")
                     } else {
-                        format!("{}", lanes)
+                        format!("{lanes}")
                     }
                 }
                 SuffixKind::Tuple => {
                     if tuple_size == 0 {
-                        panic!("type {} has no lanes!", type_kind.to_string())
+                        panic!("type {type_kind} has no lanes!")
                     } else {
-                        format!("{}", tuple_size)
+                        format!("{tuple_size}")
                     }
                 }
                 SuffixKind::Base => base_size.to_string(),
                 SuffixKind::NoX => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push('_');
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
-                    return str_suffix;
+                    format!("{prefix_q}_{prefix_char}{base_size}")
                 }
                 SuffixKind::Dup => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push('_');
-                    str_suffix.push_str("dup_");
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
+                    let mut str_suffix: String = format!("{prefix_q}_dup_{prefix_char}{base_size}");
                     if tuple_size > 0 {
                         str_suffix.push_str("_x");
                         str_suffix.push_str(tuple_size.to_string().as_str());
                     }
-                    return str_suffix;
+                    str_suffix
                 }
                 SuffixKind::DupNox => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push('_');
-                    str_suffix.push_str("dup_");
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
-                    return str_suffix;
+                    format!("{prefix_q}_dup_{prefix_char}{base_size}")
                 }
                 SuffixKind::LaneNoX => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push('_');
-                    str_suffix.push_str("lane_");
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
-                    return str_suffix;
+                    format!("{prefix_q}_lane_{prefix_char}{base_size}")
                 }
                 SuffixKind::LaneQNoX => {
-                    let mut str_suffix: String = String::new();
-                    if requires_q {
-                        str_suffix.push('q');
-                    }
-                    str_suffix.push('_');
-                    str_suffix.push_str("laneq_");
-                    str_suffix.push(prefix_char);
-                    str_suffix.push_str(base_size.to_string().as_str());
-                    return str_suffix;
+                    format!("{prefix_q}_laneq_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot270 => {
-                    if requires_q {
-                        return format!("q_rot270_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot270_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot270_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot270Lane => {
-                    if requires_q {
-                        return format!("q_rot270_lane_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot270_lane_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot270_lane_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot270LaneQ => {
-                    if requires_q {
-                        return format!("q_rot270_laneq_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot270_laneq_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot270_laneq_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot180 => {
-                    if requires_q {
-                        return format!("q_rot180_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot180_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot180_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot180Lane => {
-                    if requires_q {
-                        return format!("q_rot180_lane_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot180_lane_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot180_lane_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot180LaneQ => {
-                    if requires_q {
-                        return format!("q_rot180_laneq_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot180_laneq_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot180_laneq_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot90 => {
-                    if requires_q {
-                        return format!("q_rot90_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot90_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot90_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot90Lane => {
-                    if requires_q {
-                        return format!("q_rot90_lane_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot90_lane_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot90_lane_{prefix_char}{base_size}")
                 }
                 SuffixKind::Rot90LaneQ => {
-                    if requires_q {
-                        return format!("q_rot90_laneq_{}{}", prefix_char, base_size.to_string());
-                    }
-                    return format!("_rot90_laneq_{}{}", prefix_char, base_size.to_string());
+                    format!("{prefix_q}_rot90_laneq_{prefix_char}{base_size}")
                 }
                 SuffixKind::BaseByteSize => format!("{}", base_size / 8),
             }
@@ -272,7 +195,7 @@ impl FromStr for SuffixKind {
             "base_byte_size" => Ok(SuffixKind::BaseByteSize),
             "lane_nox" => Ok(SuffixKind::LaneNoX),
             "laneq_nox" => Ok(SuffixKind::LaneQNoX),
-            _ => Err(format!("unknown suffix type: {}", s)),
+            _ => Err(format!("unknown suffix type: {s}")),
         }
     }
 }