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.

9 files changed, 76 insertions, 170 deletions

diff --git a/library/stdarch/crates/stdarch-gen-arm/src/big_endian.rs b/library/stdarch/crates/stdarch-gen-arm/src/big_endian.rs
index 171904bbdb7..b982ff53ec3 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/big_endian.rs
+++ b/library/stdarch/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
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/context.rs b/library/stdarch/crates/stdarch-gen-arm/src/context.rs
index 751fd9f2a34..9b8eb8e8b9b 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/context.rs
+++ b/library/stdarch/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}")
                             })?)
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/expression.rs b/library/stdarch/crates/stdarch-gen-arm/src/expression.rs
index b1db251a147..56c94602fff 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/expression.rs
+++ b/library/stdarch/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,7 +358,7 @@ impl Expression {
                         false
                     }
                 }
-                _ => panic!("Badly defined function call: {:?}", fn_call),
+                _ => panic!("Badly defined function call: {fn_call:?}"),
             },
             _ => false,
         }
@@ -365,11 +366,7 @@ impl Expression {
 
     /// 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)),
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/fn_suffix.rs b/library/stdarch/crates/stdarch-gen-arm/src/fn_suffix.rs
index 9f7827776e0..26c156ae178 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/fn_suffix.rs
+++ b/library/stdarch/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}")),
         }
     }
 }
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/intrinsic.rs b/library/stdarch/crates/stdarch-gen-arm/src/intrinsic.rs
index 822bf74ef07..efaa9e14188 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/intrinsic.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/intrinsic.rs
@@ -254,6 +254,7 @@ impl Constraint {
             }
         }
 
+        #[allow(clippy::collapsible_if)]
         if let Self::SVEMaxElems {
             sve_max_elems_type: ty,
             ..
@@ -331,6 +332,7 @@ impl Signature {
             self.name.build_acle(ctx)?;
         }
 
+        #[allow(clippy::collapsible_if)]
         if let Some(ref mut return_type) = self.return_type {
             if let Some(w) = return_type.clone().wildcard() {
                 return_type.populate_wildcard(ctx.provide_type_wildcard(w)?)?;
@@ -383,10 +385,7 @@ impl ToTokens for Signature {
             .clone()
             .into_iter()
             .map(|mut arg| {
-                if arg
-                    .kind
-                    .vector()
-                    .map_or(false, |ty| ty.base_type().is_bool())
+                if arg.kind.vector().is_some_and(|ty| ty.base_type().is_bool())
                     && self.predicate_needs_conversion
                 {
                     arg.kind = TypeKind::Vector(VectorType::make_predicate_from_bitsize(8))
@@ -400,7 +399,7 @@ impl ToTokens for Signature {
         if let Some(ref return_type) = self.return_type {
             if return_type
                 .vector()
-                .map_or(false, |ty| ty.base_type().is_bool())
+                .is_some_and(|ty| ty.base_type().is_bool())
                 && self.predicate_needs_conversion
             {
                 tokens.append_all(quote! { -> svbool_t })
@@ -475,10 +474,11 @@ pub struct LLVMLink {
 
 impl LLVMLink {
     pub fn resolve(&self, cfg: &ArchitectureSettings) -> String {
-        self.name
-            .starts_with("llvm")
-            .then(|| self.name.to_string())
-            .unwrap_or_else(|| format!("{}.{}", cfg.llvm_link_prefix, self.name))
+        if self.name.starts_with("llvm") {
+            self.name.to_string()
+        } else {
+            format!("{}.{}", cfg.llvm_link_prefix, self.name)
+        }
     }
 
     pub fn build_and_save(&mut self, ctx: &mut Context) -> context::Result {
@@ -529,7 +529,7 @@ impl LLVMLink {
         if let Some(ref mut links) = self.links {
             links.iter_mut().for_each(|ele| {
                 ele.link
-                    .build(&ctx.local, TypeRepr::LLVMMachine)
+                    .build(ctx.local, TypeRepr::LLVMMachine)
                     .expect("Failed to transform to LLVMMachine representation");
             });
         } else {
@@ -1024,15 +1024,14 @@ impl Intrinsic {
         if variant.attr.is_none() && variant.assert_instr.is_none() {
             panic!(
                 "Error: {} is missing both 'attr' and 'assert_instr' fields. You must either manually declare the attributes using the 'attr' field or use 'assert_instr'!",
-                variant.signature.name.to_string()
+                variant.signature.name
             );
         }
 
         if variant.attr.is_some() {
             let attr: &Vec<Expression> = &variant.attr.clone().unwrap();
             let mut expanded_attr: Vec<Expression> = Vec::new();
-            for idx in 0..attr.len() {
-                let mut ex = attr[idx].clone();
+            for mut ex in attr.iter().cloned() {
                 ex.build(&variant, &mut ctx)?;
                 expanded_attr.push(ex);
             }
@@ -1085,6 +1084,7 @@ impl Intrinsic {
                 /* We do not want to be creating a `mut` variant if the type
                  * has one lane. If it has one lane that means it does not need
                  * shuffling */
+                #[allow(clippy::collapsible_if)]
                 if let TypeKind::Vector(vector_type) = &function_parameter.kind {
                     if vector_type.lanes() == 1 {
                         continue;
@@ -1172,7 +1172,7 @@ impl Intrinsic {
 
                 /* Now we shuffle the return value - we are creating a new
                  * return value for the intrinsic. */
-                let return_value_variable = if type_has_tuple(&return_type) {
+                let return_value_variable = if type_has_tuple(return_type) {
                     create_mut_let_variable(&ret_val_name, return_type, return_value.clone())
                 } else {
                     create_let_variable(&ret_val_name, return_type, return_value.clone())
@@ -1542,7 +1542,7 @@ impl Intrinsic {
             .get(0)
             .and_then(|arg| arg.typekind())
             .and_then(|ty| ty.base_type())
-            .map(BaseType::clone);
+            .cloned();
 
         // Add global target features
         self.target_features = ctx
@@ -1766,7 +1766,7 @@ fn create_tokens(intrinsic: &Intrinsic, endianness: Endianness, tokens: &mut Tok
 
         /* Target feature will get added here */
         let attr_expressions = &mut attr.iter().peekable();
-        while let Some(ex) = attr_expressions.next() {
+        for ex in attr_expressions {
             let mut inner = TokenStream::new();
             ex.to_tokens(&mut inner);
             tokens.append(Punct::new('#', Spacing::Alone));
@@ -1778,9 +1778,10 @@ fn create_tokens(intrinsic: &Intrinsic, endianness: Endianness, tokens: &mut Tok
         });
     }
 
+    #[allow(clippy::collapsible_if)]
     if let Some(assert_instr) = &intrinsic.assert_instr {
         if !assert_instr.is_empty() {
-            InstructionAssertionsForBaseType(&assert_instr, &intrinsic.base_type.as_ref())
+            InstructionAssertionsForBaseType(assert_instr, &intrinsic.base_type.as_ref())
                 .to_tokens(tokens)
         }
     }
@@ -1825,7 +1826,7 @@ fn create_tokens(intrinsic: &Intrinsic, endianness: Endianness, tokens: &mut Tok
 
 impl ToTokens for Intrinsic {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        if self.big_endian_compose.len() >= 1 {
+        if !self.big_endian_compose.is_empty() {
             for i in 0..2 {
                 match i {
                     0 => create_tokens(self, Endianness::Little, tokens),
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs b/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs
index a238c5fb33c..5cf39b2e11a 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs
@@ -129,6 +129,7 @@ fn generate_single_test(
     let chars = LdIntrCharacteristics::new(&load)?;
     let fn_name = load.signature.fn_name().to_string();
 
+    #[allow(clippy::collapsible_if)]
     if let Some(ty) = &chars.gather_bases_type {
         if ty.base_type().unwrap().get_size() == Ok(32)
             && chars.gather_index_type.is_none()
@@ -372,7 +373,7 @@ fn generate_single_test(
             let create = format_ident!("svcreate{tuple_len}_{acle_type}");
             quote!(#create(#(#expecteds),*))
         };
-        let input = store.input.types.get(0).unwrap().get(0).unwrap();
+        let input = store.input.types.first().unwrap().get(0).unwrap();
         let store_type = input
             .get(store.test.get_typeset_index().unwrap())
             .and_then(InputType::typekind)
@@ -579,7 +580,7 @@ struct LdIntrCharacteristics {
 
 impl LdIntrCharacteristics {
     fn new(intr: &Intrinsic) -> Result<LdIntrCharacteristics, String> {
-        let input = intr.input.types.get(0).unwrap().get(0).unwrap();
+        let input = intr.input.types.first().unwrap().get(0).unwrap();
         let load_type = input
             .get(intr.test.get_typeset_index().unwrap())
             .and_then(InputType::typekind)
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/main.rs b/library/stdarch/crates/stdarch-gen-arm/src/main.rs
index 9ea1917c14f..9bf7d0981de 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/main.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/main.rs
@@ -164,11 +164,11 @@ use stdarch_test::assert_instr;
 use super::*;{uses_neon}
 
 "#,
-        uses_neon = generated_input
-            .ctx
-            .uses_neon_types
-            .then_some("\nuse crate::core_arch::arch::aarch64::*;")
-            .unwrap_or_default(),
+        uses_neon = if generated_input.ctx.uses_neon_types {
+            "\nuse crate::core_arch::arch::aarch64::*;"
+        } else {
+            ""
+        },
     )?;
     let intrinsics = generated_input.intrinsics;
     format_code(out, quote! { #(#intrinsics)* })?;
@@ -198,7 +198,7 @@ pub fn format_code(
 /// Panics if the resulting name is empty, or if file_name() is not UTF-8.
 fn make_output_filepath(in_filepath: &Path, out_dirpath: &Path) -> PathBuf {
     make_filepath(in_filepath, out_dirpath, |_name: &str| {
-        format!("generated.rs")
+        "generated.rs".to_owned()
     })
 }
 
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/typekinds.rs b/library/stdarch/crates/stdarch-gen-arm/src/typekinds.rs
index bf22501b1dd..7c697cb7c0c 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/typekinds.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/typekinds.rs
@@ -135,7 +135,7 @@ pub enum VectorTupleSize {
 }
 
 impl VectorTupleSize {
-    pub fn to_int(&self) -> u32 {
+    pub fn to_int(self) -> u32 {
         match self {
             Self::Two => 2,
             Self::Three => 3,
@@ -453,6 +453,7 @@ impl VectorType {
         is_scalable: bool,
         tuple_size: Option<VectorTupleSize>,
     ) -> VectorType {
+        #[allow(clippy::collapsible_if)]
         if is_scalable {
             if let BaseType::Sized(BaseTypeKind::Bool, size) = base_ty {
                 return Self::make_predicate_from_bitsize(size);
@@ -521,13 +522,12 @@ impl FromStr for VectorType {
                 .transpose()
                 .unwrap();
 
-            let v = Ok(VectorType {
+            Ok(VectorType {
                 base_type,
                 is_scalable: c.name("sv_ty").is_some(),
                 lanes,
                 tuple_size,
-            });
-            return v;
+            })
         } else {
             Err(format!("invalid vector type {s:#?} given"))
         }
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/wildstring.rs b/library/stdarch/crates/stdarch-gen-arm/src/wildstring.rs
index 616c1172d49..4f8cc67f5e0 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/wildstring.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/wildstring.rs
@@ -66,7 +66,7 @@ impl WildString {
         self.0.is_empty()
     }
 
-    pub fn replace<'a, P>(&'a self, from: P, to: &str) -> WildString
+    pub fn replace<P>(&self, from: P, to: &str) -> WildString
     where
         P: Pattern + Copy,
     {