move compare_outputs implementation into SupportedArchitectureTest definition

Author: folkertdev

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

@@ -10,7 +10,6 @@ use std::fs::{self, File};
 use rayon::prelude::*;
 
 use crate::common::cli::ProcessedCli;
-use crate::common::compare::compare_outputs;
 use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
 use crate::common::gen_rust::{
     compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs, write_main_rs,
@@ -28,7 +27,17 @@ pub struct ArmArchitectureTest {
 }
 
 impl SupportedArchitectureTest for ArmArchitectureTest {
-    fn create(cli_options: ProcessedCli) -> Box<Self> {
+    type IntrinsicImpl = ArmIntrinsicType;
+
+    fn cli_options(&self) -> &ProcessedCli {
+        &self.cli_options
+    }
+
+    fn intrinsics(&self) -> &[Intrinsic<ArmIntrinsicType>] {
+        &self.intrinsics
+    }
+
+    fn create(cli_options: ProcessedCli) -> Self {
         let a32 = cli_options.target.contains("v7");
         let mut intrinsics = get_neon_intrinsics(&cli_options.filename, &cli_options.target)
             .expect("Error parsing input file");
@@ -50,10 +59,10 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             .collect::<Vec<_>>();
         intrinsics.dedup();
 
-        Box::new(Self {
+        Self {
             intrinsics,
             cli_options,
-        })
+        }
     }
 
     fn build_c_file(&self) -> bool {
@@ -177,22 +186,4 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
 
         compile_rust_programs(toolchain, target, linker)
     }
-
-    fn compare_outputs(&self) -> bool {
-        if self.cli_options.toolchain.is_some() {
-            let intrinsics_name_list = self
-                .intrinsics
-                .iter()
-                .map(|i| i.name.clone())
-                .collect::<Vec<_>>();
-
-            compare_outputs(
-                &intrinsics_name_list,
-                &self.cli_options.runner,
-                &self.cli_options.target,
-            )
-        } else {
-            true
-        }
-    }
 }

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

@@ -1,5 +1,7 @@
 use cli::ProcessedCli;
 
+use crate::common::{intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition};
+
 pub mod argument;
 pub mod cli;
 pub mod compare;
@@ -15,12 +17,33 @@ pub mod values;
 /// Architectures must support this trait
 /// to be successfully tested.
 pub trait SupportedArchitectureTest {
-    fn create(cli_options: ProcessedCli) -> Box<Self>
-    where
-        Self: Sized;
+    type IntrinsicImpl: IntrinsicTypeDefinition;
+
+    fn cli_options(&self) -> &ProcessedCli;
+    fn intrinsics(&self) -> &[Intrinsic<Self::IntrinsicImpl>];
+
+    fn create(cli_options: ProcessedCli) -> Self;
+
     fn build_c_file(&self) -> bool;
     fn build_rust_file(&self) -> bool;
-    fn compare_outputs(&self) -> bool;
+
+    fn compare_outputs(&self) -> bool {
+        if self.cli_options().toolchain.is_some() {
+            let intrinsics_name_list = self
+                .intrinsics()
+                .iter()
+                .map(|i| i.name.clone())
+                .collect::<Vec<_>>();
+
+            compare::compare_outputs(
+                &intrinsics_name_list,
+                &self.cli_options().runner,
+                &self.cli_options().target,
+            )
+        } else {
+            true
+        }
+    }
 }
 
 pub fn chunk_info(intrinsic_count: usize) -> (usize, usize) {

crates/intrinsic-test/src/main.rs

@@ -13,23 +13,16 @@ fn main() {
     let args: Cli = clap::Parser::parse();
     let processed_cli_options = ProcessedCli::new(args);
 
-    let test_environment_result: Option<Box<dyn SupportedArchitectureTest>> =
-        match processed_cli_options.target.as_str() {
-            "aarch64-unknown-linux-gnu"
-            | "armv7-unknown-linux-gnueabihf"
-            | "aarch64_be-unknown-linux-gnu" => {
-                Some(ArmArchitectureTest::create(processed_cli_options))
-            }
+    match processed_cli_options.target.as_str() {
+        "aarch64-unknown-linux-gnu"
+        | "armv7-unknown-linux-gnueabihf"
+        | "aarch64_be-unknown-linux-gnu" => run(ArmArchitectureTest::create(processed_cli_options)),
 
-            _ => None,
-        };
-
-    if test_environment_result.is_none() {
-        std::process::exit(0);
+        _ => std::process::exit(0),
     }
+}
 
-    let test_environment = test_environment_result.unwrap();
-
+fn run(test_environment: impl SupportedArchitectureTest) {
     info!("building C binaries");
     if !test_environment.build_c_file() {
         std::process::exit(2);