intrinsic-test: Modernization of the coding style

It modernizes the coding style of the crate intrinsic-test by fixing
Clippy warnings.

Clippy: rust version 1.89.0-nightly (6f6971078 2025-05-28)
Number of Fixed Warnings: 36/36

Author: a4lg

crates/intrinsic-test/src/arm/compile.rs

@@ -2,7 +2,7 @@ use crate::common::compile_c::CompilationCommandBuilder;
 use crate::common::gen_c::compile_c_programs;
 
 pub fn compile_c_arm(
-    intrinsics_name_list: &Vec<String>,
+    intrinsics_name_list: &[String],
     compiler: &str,
     target: &str,
     cxx_toolchain_dir: Option<&str>,
@@ -56,7 +56,7 @@ pub fn compile_c_arm(
                 .clone()
                 .set_input_name(intrinsic_name)
                 .set_output_name(intrinsic_name)
-                .to_string()
+                .make_string()
         })
         .collect::<Vec<_>>();
 

crates/intrinsic-test/src/arm/json_parser.rs

@@ -54,7 +54,7 @@ struct JsonIntrinsic {
 
 pub fn get_neon_intrinsics(
     filename: &Path,
-    target: &String,
+    target: &str,
 ) -> Result<Vec<Intrinsic<ArmIntrinsicType>>, Box<dyn std::error::Error>> {
     let file = std::fs::File::open(filename)?;
     let reader = std::io::BufReader::new(file);
@@ -75,7 +75,7 @@ pub fn get_neon_intrinsics(
 
 fn json_to_intrinsic(
     mut intr: JsonIntrinsic,
-    target: &String,
+    target: &str,
 ) -> Result<Intrinsic<ArmIntrinsicType>, Box<dyn std::error::Error>> {
     let name = intr.name.replace(['[', ']'], "");
 

crates/intrinsic-test/src/arm/mod.rs

@@ -45,8 +45,8 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         intrinsics.dedup();
 
         Box::new(Self {
-            intrinsics: intrinsics,
-            cli_options: cli_options,
+            intrinsics,
+            cli_options,
         })
     }
 
@@ -71,9 +71,12 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
 
         match compiler {
             None => true,
-            Some(compiler) => {
-                compile_c_arm(&intrinsics_name_list, compiler, target, cxx_toolchain_dir)
-            }
+            Some(compiler) => compile_c_arm(
+                intrinsics_name_list.as_slice(),
+                compiler,
+                target,
+                cxx_toolchain_dir,
+            ),
         }
     }
 

crates/intrinsic-test/src/arm/types.rs

@@ -12,9 +12,9 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             (self.0.bit_len, self.0.simd_len, self.0.vec_len)
         {
             match (simd_len, vec_len) {
-                (None, None) => format!("{}{}{}_t", const_prefix, prefix, bit_len),
-                (Some(simd), None) => format!("{}{bit_len}x{simd}_t", prefix),
-                (Some(simd), Some(vec)) => format!("{}{bit_len}x{simd}x{vec}_t", prefix),
+                (None, None) => format!("{const_prefix}{prefix}{bit_len}_t"),
+                (Some(simd), None) => format!("{prefix}{bit_len}x{simd}_t"),
+                (Some(simd), Some(vec)) => format!("{prefix}{bit_len}x{simd}x{vec}_t"),
                 (None, Some(_)) => todo!("{:#?}", self), // Likely an invalid case
             }
         } else {
@@ -24,8 +24,10 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
 
     fn c_single_vector_type(&self) -> String {
         if let (Some(bit_len), Some(simd_len)) = (self.0.bit_len, self.0.simd_len) {
-            let prefix = self.0.kind.c_prefix();
-            format!("{}{bit_len}x{simd_len}_t", prefix)
+            format!(
+                "{prefix}{bit_len}x{simd_len}_t",
+                prefix = self.0.kind.c_prefix()
+            )
         } else {
             unreachable!("Shouldn't be called on this type")
         }
@@ -40,9 +42,9 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             (self.0.bit_len, self.0.simd_len, self.0.vec_len)
         {
             match (simd_len, vec_len) {
-                (None, None) => format!("{}{bit_len}", rust_prefix),
-                (Some(simd), None) => format!("{}{bit_len}x{simd}_t", c_prefix),
-                (Some(simd), Some(vec)) => format!("{}{bit_len}x{simd}x{vec}_t", c_prefix),
+                (None, None) => format!("{rust_prefix}{bit_len}"),
+                (Some(simd), None) => format!("{c_prefix}{bit_len}x{simd}_t"),
+                (Some(simd), Some(vec)) => format!("{c_prefix}{bit_len}x{simd}x{vec}_t"),
                 (None, Some(_)) => todo!("{:#?}", self), // Likely an invalid case
             }
         } else {
@@ -119,7 +121,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
         }
     }
 
-    fn from_c(s: &str, target: &String) -> Result<Box<Self>, String> {
+    fn from_c(s: &str, target: &str) -> Result<Box<Self>, String> {
         const CONST_STR: &str = "const";
         if let Some(s) = s.strip_suffix('*') {
             let (s, constant) = match s.trim().strip_suffix(CONST_STR) {
@@ -128,11 +130,11 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             };
             let s = s.trim_end();
             let temp_return = ArmIntrinsicType::from_c(s, target);
-            temp_return.and_then(|mut op| {
+            temp_return.map(|mut op| {
                 let edited = op.as_mut();
                 edited.0.ptr = true;
                 edited.0.ptr_constant = constant;
-                Ok(op)
+                op
             })
         } else {
             // [const ]TYPE[{bitlen}[x{simdlen}[x{vec_len}]]][_t]

crates/intrinsic-test/src/common/argument.rs

@@ -33,7 +33,7 @@ where
     }
 
     pub fn has_constraint(&self) -> bool {
-        !self.constraint.is_some()
+        self.constraint.is_none()
     }
 
     pub fn type_and_name_from_c(arg: &str) -> (&str, &str) {
@@ -65,7 +65,7 @@ where
     pub fn from_c(
         pos: usize,
         arg: &str,
-        target: &String,
+        target: &str,
         constraint: Option<Constraint>,
     ) -> Argument<T> {
         let (ty, var_name) = Self::type_and_name_from_c(arg);
@@ -127,15 +127,14 @@ where
     /// e.g `const int32x2_t a_vals = {0x3effffff, 0x3effffff, 0x3f7fffff}`, if loads=2.
     pub fn gen_arglists_c(&self, indentation: Indentation, loads: u32) -> String {
         self.iter()
-            .filter_map(|arg| {
-                (!arg.has_constraint()).then(|| {
-                    format!(
-                        "{indentation}const {ty} {name}_vals[] = {values};",
-                        ty = arg.ty.c_scalar_type(),
-                        name = arg.name,
-                        values = arg.ty.populate_random(indentation, loads, &Language::C)
-                    )
-                })
+            .filter(|&arg| !arg.has_constraint())
+            .map(|arg| {
+                format!(
+                    "{indentation}const {ty} {name}_vals[] = {values};",
+                    ty = arg.ty.c_scalar_type(),
+                    name = arg.name,
+                    values = arg.ty.populate_random(indentation, loads, &Language::C)
+                )
             })
             .collect::<Vec<_>>()
             .join("\n")
@@ -145,17 +144,16 @@ where
     /// values can be loaded as a sliding window, e.g `const A_VALS: [u32; 20]  = [...];`
     pub fn gen_arglists_rust(&self, indentation: Indentation, loads: u32) -> String {
         self.iter()
-            .filter_map(|arg| {
-                (!arg.has_constraint()).then(|| {
-                    format!(
-                        "{indentation}{bind} {name}: [{ty}; {load_size}] = {values};",
-                        bind = arg.rust_vals_array_binding(),
-                        name = arg.rust_vals_array_name(),
-                        ty = arg.ty.rust_scalar_type(),
-                        load_size = arg.ty.num_lanes() * arg.ty.num_vectors() + loads - 1,
-                        values = arg.ty.populate_random(indentation, loads, &Language::Rust)
-                    )
-                })
+            .filter(|&arg| !arg.has_constraint())
+            .map(|arg| {
+                format!(
+                    "{indentation}{bind} {name}: [{ty}; {load_size}] = {values};",
+                    bind = arg.rust_vals_array_binding(),
+                    name = arg.rust_vals_array_name(),
+                    ty = arg.ty.rust_scalar_type(),
+                    load_size = arg.ty.num_lanes() * arg.ty.num_vectors() + loads - 1,
+                    values = arg.ty.populate_random(indentation, loads, &Language::Rust)
+                )
             })
             .collect::<Vec<_>>()
             .join("\n")
@@ -168,22 +166,18 @@ where
     /// ARM-specific
     pub fn load_values_c(&self, indentation: Indentation) -> String {
         self.iter()
-            .filter_map(|arg| {
-                // The ACLE doesn't support 64-bit polynomial loads on Armv7
-                // This and the cast are a workaround for this
-
-                (!arg.has_constraint()).then(|| {
-                    format!(
-                        "{indentation}{ty} {name} = cast<{ty}>({load}(&{name}_vals[i]));\n",
-                        ty = arg.to_c_type(),
-                        name = arg.name,
-                        load = if arg.is_simd() {
-                            arg.ty.get_load_function(Language::C)
-                        } else {
-                            "*".to_string()
-                        }
-                    )
-                })
+            .filter(|&arg| !arg.has_constraint())
+            .map(|arg| {
+                format!(
+                    "{indentation}{ty} {name} = cast<{ty}>({load}(&{name}_vals[i]));\n",
+                    ty = arg.to_c_type(),
+                    name = arg.name,
+                    load = if arg.is_simd() {
+                        arg.ty.get_load_function(Language::C)
+                    } else {
+                        "*".to_string()
+                    }
+                )
             })
             .collect()
     }
@@ -193,19 +187,18 @@ where
     /// e.g `let a = vld1_u8(A_VALS.as_ptr().offset(i));`
     pub fn load_values_rust(&self, indentation: Indentation) -> String {
         self.iter()
-            .filter_map(|arg| {
-                (!arg.has_constraint()).then(|| {
-                    format!(
-                        "{indentation}let {name} = {load}({vals_name}.as_ptr().offset(i));\n",
-                        name = arg.name,
-                        vals_name = arg.rust_vals_array_name(),
-                        load = if arg.is_simd() {
-                            arg.ty.get_load_function(Language::Rust)
-                        } else {
-                            "*".to_string()
-                        },
-                    )
-                })
+            .filter(|&arg| !arg.has_constraint())
+            .map(|arg| {
+                format!(
+                    "{indentation}let {name} = {load}({vals_name}.as_ptr().offset(i));\n",
+                    name = arg.name,
+                    vals_name = arg.rust_vals_array_name(),
+                    load = if arg.is_simd() {
+                        arg.ty.get_load_function(Language::Rust)
+                    } else {
+                        "*".to_string()
+                    },
+                )
             })
             .collect()
     }

crates/intrinsic-test/src/common/cli.rs

@@ -100,14 +100,14 @@ impl ProcessedCli {
         };
 
         Self {
-            toolchain: toolchain,
-            cpp_compiler: cpp_compiler,
-            c_runner: c_runner,
-            target: target,
-            linker: linker,
-            cxx_toolchain_dir: cxx_toolchain_dir,
-            skip: skip,
-            filename: filename,
+            toolchain,
+            cpp_compiler,
+            c_runner,
+            target,
+            linker,
+            cxx_toolchain_dir,
+            skip,
+            filename,
         }
     }
 }

crates/intrinsic-test/src/common/compile_c.rs

@@ -100,10 +100,10 @@ impl CompilationCommandBuilder {
 }
 
 impl CompilationCommandBuilder {
-    pub fn to_string(self) -> String {
+    pub fn make_string(self) -> String {
         let arch_flags = self.arch_flags.join("+");
         let flags = std::env::var("CPPFLAGS").unwrap_or("".into());
-        let project_root = self.project_root.unwrap_or(String::new());
+        let project_root = self.project_root.unwrap_or_default();
         let project_root_str = project_root.as_str();
         let mut output = self.output.clone();
         if self.linker.is_some() {

crates/intrinsic-test/src/common/gen_c.rs

@@ -58,7 +58,7 @@ int main(int argc, char **argv) {{
             .map(|header| format!("#include <{header}>"))
             .collect::<Vec<_>>()
             .join("\n"),
-        arch_specific_definitions = arch_specific_definitions.into_iter().join("\n"),
+        arch_specific_definitions = arch_specific_definitions.join("\n"),
     )
 }
 

crates/intrinsic-test/src/common/gen_rust.rs

@@ -130,9 +130,9 @@ pub fn setup_rust_file_paths(identifiers: &Vec<String>) -> BTreeMap<&String, Str
     identifiers
         .par_iter()
         .map(|identifier| {
-            let rust_dir = format!(r#"rust_programs/{}"#, identifier);
+            let rust_dir = format!("rust_programs/{identifier}");
             let _ = std::fs::create_dir_all(&rust_dir);
-            let rust_filename = format!(r#"{rust_dir}/main.rs"#);
+            let rust_filename = format!("{rust_dir}/main.rs");
 
             (identifier, rust_filename)
         })

crates/intrinsic-test/src/common/intrinsic_helpers.rs

@@ -117,11 +117,11 @@ impl IntrinsicType {
     }
 
     pub fn num_lanes(&self) -> u32 {
-        if let Some(sl) = self.simd_len { sl } else { 1 }
+        self.simd_len.unwrap_or(1)
     }
 
     pub fn num_vectors(&self) -> u32 {
-        if let Some(vl) = self.vec_len { vl } else { 1 }
+        self.vec_len.unwrap_or(1)
     }
 
     pub fn is_simd(&self) -> bool {
@@ -266,7 +266,7 @@ impl IntrinsicType {
 
     pub fn as_call_param_c(&self, name: &String) -> String {
         if self.ptr {
-            format!("&{}", name)
+            format!("&{name}")
         } else {
             name.clone()
         }
@@ -282,7 +282,7 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
     fn get_lane_function(&self) -> String;
 
     /// can be implemented in an `impl` block
-    fn from_c(_s: &str, _target: &String) -> Result<Box<Self>, String>;
+    fn from_c(_s: &str, _target: &str) -> Result<Box<Self>, String>;
 
     /// Gets a string containing the typename for this type in C format.
     /// can be directly defined in `impl` blocks