diff --git a/crates/intrinsic-test/src/arm/intrinsic.rs b/crates/intrinsic-test/src/arm/intrinsic.rs
index a54e585719..bcbee3503b 100644
--- a/crates/intrinsic-test/src/arm/intrinsic.rs
+++ b/crates/intrinsic-test/src/arm/intrinsic.rs
@@ -2,9 +2,9 @@ use crate::common::intrinsic_helpers::IntrinsicType;
 use std::ops::{Deref, DerefMut};
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct ArmIntrinsicType(pub IntrinsicType);
+pub struct ArmType(pub IntrinsicType);
 
-impl Deref for ArmIntrinsicType {
+impl Deref for ArmType {
     type Target = IntrinsicType;
 
     fn deref(&self) -> &Self::Target {
@@ -12,7 +12,7 @@ impl Deref for ArmIntrinsicType {
     }
 }
 
-impl DerefMut for ArmIntrinsicType {
+impl DerefMut for ArmType {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
diff --git a/crates/intrinsic-test/src/arm/json_parser.rs b/crates/intrinsic-test/src/arm/json_parser.rs
index 06cf78a422..b4e21a5757 100644
--- a/crates/intrinsic-test/src/arm/json_parser.rs
+++ b/crates/intrinsic-test/src/arm/json_parser.rs
@@ -1,4 +1,5 @@
-use super::intrinsic::ArmIntrinsicType;
+use super::intrinsic::ArmType;
+use crate::arm::Arm;
 use crate::arm::types::parse_intrinsic_type;
 use crate::common::argument::{Argument, ArgumentList};
 use crate::common::constraint::Constraint;
@@ -59,7 +60,7 @@ struct JsonIntrinsic {
 
 pub fn get_neon_intrinsics(
     filename: &Path,
-) -> Result<Vec<Intrinsic<ArmIntrinsicType>>, Box<dyn std::error::Error>> {
+) -> Result<Vec<Intrinsic<Arm>>, Box<dyn std::error::Error>> {
     let file = std::fs::File::open(filename)?;
     let reader = std::io::BufReader::new(file);
     let json: Vec<JsonIntrinsic> = serde_json::from_reader(reader).expect("Couldn't parse JSON");
@@ -79,10 +80,10 @@ pub fn get_neon_intrinsics(
 
 fn json_to_intrinsic(
     mut intr: JsonIntrinsic,
-) -> Result<Intrinsic<ArmIntrinsicType>, Box<dyn std::error::Error>> {
+) -> Result<Intrinsic<Arm>, Box<dyn std::error::Error>> {
     let name = intr.name.replace(['[', ']'], "");
 
-    let result_ty = ArmIntrinsicType(parse_intrinsic_type(&intr.return_type.value)?);
+    let result_ty = ArmType(parse_intrinsic_type(&intr.return_type.value)?);
 
     let args = intr
         .arguments
@@ -120,12 +121,8 @@ fn json_to_intrinsic(
                     }
                 });
 
-            let mut arg = Argument::<ArmIntrinsicType>::new(
-                i,
-                String::from(arg_name),
-                ArmIntrinsicType(arg_ty),
-                constraint,
-            );
+            let mut arg =
+                Argument::<Arm>::new(i, String::from(arg_name), ArmType(arg_ty), constraint);
 
             // The JSON doesn't list immediates as const
             let IntrinsicType {
@@ -138,7 +135,7 @@ fn json_to_intrinsic(
         })
         .collect();
 
-    let arguments = ArgumentList::<ArmIntrinsicType> { args };
+    let arguments = ArgumentList::<Arm> { args };
 
     Ok(Intrinsic {
         name,
diff --git a/crates/intrinsic-test/src/arm/mod.rs b/crates/intrinsic-test/src/arm/mod.rs
index 378f23ba7c..aa83f194b3 100644
--- a/crates/intrinsic-test/src/arm/mod.rs
+++ b/crates/intrinsic-test/src/arm/mod.rs
@@ -3,22 +3,21 @@ mod intrinsic;
 mod json_parser;
 mod types;
 
-use crate::common::SupportedArchitectureTest;
+use crate::common::SupportedArchitecture;
 use crate::common::cli::{CcArgStyle, ProcessedCli};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
-use intrinsic::ArmIntrinsicType;
+use intrinsic::ArmType;
 use json_parser::get_neon_intrinsics;
 
-pub struct ArmArchitectureTest {
-    intrinsics: Vec<Intrinsic<ArmIntrinsicType>>,
-}
+#[derive(PartialEq)]
+pub struct Arm(Vec<Intrinsic<Arm>>);
 
-impl SupportedArchitectureTest for ArmArchitectureTest {
-    type IntrinsicImpl = ArmIntrinsicType;
+impl SupportedArchitecture for Arm {
+    type Type = ArmType;
 
-    fn intrinsics(&self) -> &[Intrinsic<ArmIntrinsicType>] {
-        &self.intrinsics
+    fn intrinsics(&self) -> &[Intrinsic<Self>] {
+        &self.0
     }
 
     const NOTICE: &str = config::NOTICE;
@@ -66,6 +65,6 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             .take(sample_size)
             .collect::<Vec<_>>();
 
-        Self { intrinsics }
+        Self(intrinsics)
     }
 }
diff --git a/crates/intrinsic-test/src/arm/types.rs b/crates/intrinsic-test/src/arm/types.rs
index cd420f1067..44af107eb9 100644
--- a/crates/intrinsic-test/src/arm/types.rs
+++ b/crates/intrinsic-test/src/arm/types.rs
@@ -1,9 +1,7 @@
-use super::intrinsic::ArmIntrinsicType;
-use crate::common::intrinsic_helpers::{
-    IntrinsicType, IntrinsicTypeDefinition, Sign, SimdLen, TypeKind,
-};
+use super::intrinsic::ArmType;
+use crate::common::intrinsic_helpers::{IntrinsicType, Sign, SimdLen, TypeDefinition, TypeKind};
 
-impl IntrinsicTypeDefinition for ArmIntrinsicType {
+impl TypeDefinition for ArmType {
     /// Gets a string containing the typename for this type in C format.
     fn c_type(&self) -> String {
         let prefix = self.kind.c_prefix();
diff --git a/crates/intrinsic-test/src/common/argument.rs b/crates/intrinsic-test/src/common/argument.rs
index eaec5b71c4..d178f500d5 100644
--- a/crates/intrinsic-test/src/common/argument.rs
+++ b/crates/intrinsic-test/src/common/argument.rs
@@ -1,30 +1,31 @@
 use itertools::Itertools;
 
+use crate::common::SupportedArchitecture;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::values::test_values_array_name;
 
 use super::PASSES;
 use super::constraint::Constraint;
-use super::intrinsic_helpers::IntrinsicTypeDefinition;
+use super::intrinsic_helpers::TypeDefinition;
 
 /// An argument for the intrinsic.
 #[derive(Debug, PartialEq, Clone)]
-pub struct Argument<T: IntrinsicTypeDefinition> {
+pub struct Argument<A: SupportedArchitecture> {
     /// The argument's index in the intrinsic function call.
     pub pos: usize,
     /// The argument name.
     pub name: String,
     /// The type of the argument.
-    pub ty: T,
+    pub ty: A::Type,
     /// Any constraints that are on this argument
     pub constraint: Option<Constraint>,
 }
 
-impl<T> Argument<T>
+impl<A> Argument<A>
 where
-    T: IntrinsicTypeDefinition,
+    A: SupportedArchitecture,
 {
-    pub fn new(pos: usize, name: String, ty: T, constraint: Option<Constraint>) -> Self {
+    pub fn new(pos: usize, name: String, ty: A::Type, constraint: Option<Constraint>) -> Self {
         Argument {
             pos,
             name,
@@ -63,13 +64,13 @@ where
 
 /// Arguments of an intrinsic - including parameters that end up being const generics.
 #[derive(Debug, PartialEq, Clone)]
-pub struct ArgumentList<T: IntrinsicTypeDefinition> {
-    pub args: Vec<Argument<T>>,
+pub struct ArgumentList<A: SupportedArchitecture> {
+    pub args: Vec<Argument<A>>,
 }
 
-impl<T> ArgumentList<T>
+impl<A> ArgumentList<A>
 where
-    T: IntrinsicTypeDefinition,
+    A: SupportedArchitecture,
 {
     /// Returns a string with the arguments in `self` as a parameter list for a wrapper fn
     /// definition in C (e.g. `$ty1 $arg1, $ty2 $arg2`).
@@ -196,7 +197,7 @@ where
     }
 
     /// Returns an iterator over the contained arguments
-    pub fn iter(&self) -> std::slice::Iter<'_, Argument<T>> {
+    pub fn iter(&self) -> std::slice::Iter<'_, Argument<A>> {
         self.args.iter()
     }
 }
diff --git a/crates/intrinsic-test/src/common/gen_c.rs b/crates/intrinsic-test/src/common/gen_c.rs
index 24756324c4..e4b6c9815c 100644
--- a/crates/intrinsic-test/src/common/gen_c.rs
+++ b/crates/intrinsic-test/src/common/gen_c.rs
@@ -1,8 +1,8 @@
 use itertools::Itertools;
 
-use crate::common::intrinsic::Intrinsic;
+use crate::common::{SupportedArchitecture, intrinsic::Intrinsic};
 
-use super::intrinsic_helpers::IntrinsicTypeDefinition;
+use super::intrinsic_helpers::TypeDefinition;
 
 /// Generates a C source file containing wrapper functions around each specialisation of each
 /// intrinsic (that is, intrinsics with specific values for the the immediate arguments). Each
@@ -14,11 +14,11 @@ use super::intrinsic_helpers::IntrinsicTypeDefinition;
 ///    *__dst = __crc32cd(a, b);
 /// }
 /// ```
-pub fn write_wrapper_c<T: IntrinsicTypeDefinition>(
+pub fn write_wrapper_c<A: SupportedArchitecture>(
     w: &mut impl std::io::Write,
     notice: &str,
     platform_headers: &[&str],
-    intrinsics: &[Intrinsic<T>],
+    intrinsics: &[Intrinsic<A>],
 ) -> std::io::Result<()> {
     write!(w, "{notice}")?;
 
diff --git a/crates/intrinsic-test/src/common/gen_rust.rs b/crates/intrinsic-test/src/common/gen_rust.rs
index 02f6e40dc0..d615240447 100644
--- a/crates/intrinsic-test/src/common/gen_rust.rs
+++ b/crates/intrinsic-test/src/common/gen_rust.rs
@@ -2,12 +2,12 @@ use std::process::Command;
 
 use itertools::Itertools;
 
-use super::intrinsic_helpers::IntrinsicTypeDefinition;
-use crate::common::PASSES;
+use super::intrinsic_helpers::TypeDefinition;
 use crate::common::cli::{CcArgStyle, ProcessedCli};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::values::{test_values_array_name, test_values_array_static};
+use crate::common::{PASSES, SupportedArchitecture};
 
 /// Rust definitions that are included verbatim in the generated source. In particular, defines
 /// a wrapper around float types that defines `NaN`s to be equal reflexively to enable
@@ -102,15 +102,12 @@ pub fn write_lib_cargo_toml(w: &mut impl std::io::Write, name: &str) -> std::io:
 
 /// Writes a Rust source file into `w` with common definitions, static arrays with test values,
 /// declarations of C wrapper functions for FFI and Rust test functions.
-pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
+pub fn write_lib_rs<A: SupportedArchitecture>(
     w: &mut impl std::io::Write,
-    notice: &str,
-    cfg: &str,
-    definitions: &str,
     i: usize,
-    intrinsics: &[Intrinsic<T>],
+    intrinsics: &[Intrinsic<A>],
 ) -> std::io::Result<()> {
-    write!(w, "{notice}")?;
+    write!(w, "{}", A::NOTICE)?;
 
     writeln!(w, "#![feature(simd_ffi)]")?;
     writeln!(w, "#![feature(f16)]")?;
@@ -121,11 +118,11 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
     writeln!(w, "#![allow(non_camel_case_types)]")?;
     writeln!(w, "#![allow(non_snake_case)]")?;
 
-    writeln!(w, "{cfg}")?;
+    writeln!(w, "{}", A::PLATFORM_RUST_CFGS)?;
 
     writeln!(w, "{}", COMMON_RUST_DEFINITIONS)?;
 
-    writeln!(w, "{definitions}")?;
+    writeln!(w, "{}", A::PLATFORM_RUST_DEFINITIONS)?;
 
     let mut seen = std::collections::HashSet::new();
 
@@ -157,9 +154,9 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
 /// (first loop) `PASSES` number of times (second loop). For a given iteration of a given
 /// specialisation, test values are loaded for each argument and passed to the Rust intrinsic
 /// and the C wrapper function, and the results are compared.
-fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
+fn generate_rust_test_loop<A: SupportedArchitecture>(
     w: &mut impl std::io::Write,
-    intrinsic: &Intrinsic<T>,
+    intrinsic: &Intrinsic<A>,
 ) -> std::io::Result<()> {
     let intrinsic_name = &intrinsic.name;
 
@@ -251,9 +248,9 @@ fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
 
 /// Writes a test function for an given intrinsic to `w`, with a body generated by
 /// `generate_rust_test_loop`.
-fn create_rust_test<T: IntrinsicTypeDefinition>(
+fn create_rust_test<A: SupportedArchitecture>(
     w: &mut impl std::io::Write,
-    intrinsic: &Intrinsic<T>,
+    intrinsic: &Intrinsic<A>,
 ) -> std::io::Result<()> {
     trace!("generating `{}`", intrinsic.name);
 
@@ -272,10 +269,10 @@ fn create_rust_test<T: IntrinsicTypeDefinition>(
 
 /// Writes an `extern "C"` block with function declarations for each of the C wrapper functions into
 /// `w`.
-pub fn write_bindings_rust<T: IntrinsicTypeDefinition>(
+pub fn write_bindings_rust<A: SupportedArchitecture>(
     w: &mut impl std::io::Write,
     i: usize,
-    intrinsics: &[Intrinsic<T>],
+    intrinsics: &[Intrinsic<A>],
 ) -> std::io::Result<()> {
     write!(
         w,
diff --git a/crates/intrinsic-test/src/common/intrinsic.rs b/crates/intrinsic-test/src/common/intrinsic.rs
index d69644388a..e07282d3de 100644
--- a/crates/intrinsic-test/src/common/intrinsic.rs
+++ b/crates/intrinsic-test/src/common/intrinsic.rs
@@ -1,19 +1,17 @@
-use crate::common::constraint::Constraint;
-
 use super::argument::ArgumentList;
-use super::intrinsic_helpers::IntrinsicTypeDefinition;
+use crate::common::{SupportedArchitecture, constraint::Constraint};
 
 /// An intrinsic
 #[derive(Debug, PartialEq, Clone)]
-pub struct Intrinsic<T: IntrinsicTypeDefinition> {
+pub struct Intrinsic<A: SupportedArchitecture> {
     /// The function name of this intrinsic.
     pub name: String,
 
     /// Any arguments for this intrinsic.
-    pub arguments: ArgumentList<T>,
+    pub arguments: ArgumentList<A>,
 
     /// The return type of this intrinsic.
-    pub results: T,
+    pub results: A::Type,
 
     /// Any architecture-specific tags.
     pub arch_tags: Vec<String>,
@@ -40,7 +38,7 @@ fn recurse_specializations<'a, E>(
     }
 }
 
-impl<T: IntrinsicTypeDefinition> Intrinsic<T> {
+impl<A: SupportedArchitecture> Intrinsic<A> {
     /// Invokes `f` for "specialisation" of the intrinsic - a specific instantiation of the
     /// constant generics of the intrinsic. `f` takes a slice where the `i`th element corresponds
     /// to the value of the `i`th const generic argument of the intrinsic.
diff --git a/crates/intrinsic-test/src/common/intrinsic_helpers.rs b/crates/intrinsic-test/src/common/intrinsic_helpers.rs
index ca5aeba86d..0e1b699293 100644
--- a/crates/intrinsic-test/src/common/intrinsic_helpers.rs
+++ b/crates/intrinsic-test/src/common/intrinsic_helpers.rs
@@ -195,7 +195,7 @@ impl IntrinsicType {
     }
 }
 
-pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
+pub trait TypeDefinition: Clone + Deref<Target = IntrinsicType> {
     /// Determines the load function for this type.
     fn get_load_function(&self) -> String;
 
diff --git a/crates/intrinsic-test/src/common/mod.rs b/crates/intrinsic-test/src/common/mod.rs
index b577491454..ff0b6cbbaf 100644
--- a/crates/intrinsic-test/src/common/mod.rs
+++ b/crates/intrinsic-test/src/common/mod.rs
@@ -10,7 +10,7 @@ use crate::common::{
         run_rustfmt, write_bin_cargo_toml, write_build_rs, write_lib_cargo_toml, write_lib_rs,
     },
     intrinsic::Intrinsic,
-    intrinsic_helpers::IntrinsicTypeDefinition,
+    intrinsic_helpers::TypeDefinition,
 };
 
 pub mod argument;
@@ -29,10 +29,10 @@ pub(crate) const PASSES: u32 = 20;
 
 /// Architectures must support this trait
 /// to be successfully tested.
-pub trait SupportedArchitectureTest {
-    type IntrinsicImpl: IntrinsicTypeDefinition + Sync;
+pub trait SupportedArchitecture: Sized {
+    type Type: TypeDefinition + std::fmt::Debug + PartialEq + Sync;
 
-    fn intrinsics(&self) -> &[Intrinsic<Self::IntrinsicImpl>];
+    fn intrinsics(&self) -> &[Intrinsic<Self>];
 
     fn create(cli_options: &ProcessedCli) -> Self;
 
@@ -81,14 +81,7 @@ pub trait SupportedArchitectureTest {
                 trace!("generating `{rust_filename}`");
                 let mut file = File::create(&rust_filename)?;
 
-                write_lib_rs(
-                    &mut file,
-                    Self::NOTICE,
-                    Self::PLATFORM_RUST_CFGS,
-                    Self::PLATFORM_RUST_DEFINITIONS,
-                    i,
-                    chunk,
-                )?;
+                write_lib_rs(&mut file, i, chunk)?;
                 run_rustfmt(&rust_filename);
 
                 let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
diff --git a/crates/intrinsic-test/src/common/values.rs b/crates/intrinsic-test/src/common/values.rs
index 4c3dd078e0..a3c0e09797 100644
--- a/crates/intrinsic-test/src/common/values.rs
+++ b/crates/intrinsic-test/src/common/values.rs
@@ -2,7 +2,7 @@ use itertools::Itertools as _;
 
 use crate::common::{
     PASSES,
-    intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, SimdLen, TypeKind},
+    intrinsic_helpers::{IntrinsicType, Sign, SimdLen, TypeDefinition, TypeKind},
 };
 
 /// Maximum size of a SVE vector
@@ -18,7 +18,7 @@ pub const MAX_SVE_BITS: u32 = 2048;
 ///     0x80, 0x3b, 0xff,
 /// ];
 /// ```
-pub fn test_values_array_static<T: IntrinsicTypeDefinition>(
+pub fn test_values_array_static<T: TypeDefinition>(
     w: &mut impl std::io::Write,
     ty: &T,
 ) -> std::io::Result<()> {
@@ -34,7 +34,7 @@ pub fn test_values_array_static<T: IntrinsicTypeDefinition>(
 
 /// Returns a string with the name of the static variable containing test values for intrinsic
 /// arguments of this type.
-pub fn test_values_array_name<T: IntrinsicTypeDefinition>(ty: &T) -> String {
+pub fn test_values_array_name<T: TypeDefinition>(ty: &T) -> String {
     format!(
         "{ty}_{load_size}",
         ty = ty.rust_scalar_type().to_uppercase(),
diff --git a/crates/intrinsic-test/src/main.rs b/crates/intrinsic-test/src/main.rs
index 4c0136041f..e25eb48a45 100644
--- a/crates/intrinsic-test/src/main.rs
+++ b/crates/intrinsic-test/src/main.rs
@@ -5,10 +5,10 @@ mod arm;
 mod common;
 mod x86;
 
-use arm::ArmArchitectureTest;
-use common::SupportedArchitectureTest;
+use arm::Arm;
+use common::SupportedArchitecture;
 use common::cli::{Cli, ProcessedCli};
-use x86::X86ArchitectureTest;
+use x86::X86;
 
 fn main() {
     pretty_env_logger::init();
@@ -18,21 +18,15 @@ fn main() {
     if processed_cli_options.target.starts_with("arm")
         | processed_cli_options.target.starts_with("aarch64")
     {
-        run(
-            ArmArchitectureTest::create(&processed_cli_options),
-            processed_cli_options,
-        )
+        run(Arm::create(&processed_cli_options), processed_cli_options)
     } else if processed_cli_options.target.starts_with("x86") {
-        run(
-            X86ArchitectureTest::create(&processed_cli_options),
-            processed_cli_options,
-        )
+        run(X86::create(&processed_cli_options), processed_cli_options)
     } else {
         unimplemented!("Unsupported target {}", processed_cli_options.target)
     }
 }
 
-fn run(test_environment: impl SupportedArchitectureTest, processed_cli_options: ProcessedCli) {
+fn run(test_environment: impl SupportedArchitecture, processed_cli_options: ProcessedCli) {
     info!("building C binaries");
     test_environment.generate_c_file();
 
diff --git a/crates/intrinsic-test/src/x86/mod.rs b/crates/intrinsic-test/src/x86/mod.rs
index 288bd8bdf8..ec198d9218 100644
--- a/crates/intrinsic-test/src/x86/mod.rs
+++ b/crates/intrinsic-test/src/x86/mod.rs
@@ -4,21 +4,21 @@ mod intrinsic;
 mod types;
 mod xml_parser;
 
-use crate::common::SupportedArchitectureTest;
+use crate::common::SupportedArchitecture;
 use crate::common::cli::ProcessedCli;
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use intrinsic::X86IntrinsicType;
 use xml_parser::get_xml_intrinsics;
 
-pub struct X86ArchitectureTest {
-    intrinsics: Vec<Intrinsic<X86IntrinsicType>>,
+pub struct X86 {
+    intrinsics: Vec<Intrinsic<X86>>,
 }
 
-impl SupportedArchitectureTest for X86ArchitectureTest {
-    type IntrinsicImpl = X86IntrinsicType;
+impl SupportedArchitecture for X86 {
+    type Type = X86IntrinsicType;
 
-    fn intrinsics(&self) -> &[Intrinsic<X86IntrinsicType>] {
+    fn intrinsics(&self) -> &[Intrinsic<Self>] {
         &self.intrinsics
     }
 
diff --git a/crates/intrinsic-test/src/x86/types.rs b/crates/intrinsic-test/src/x86/types.rs
index a0e14c77d6..b7e063e228 100644
--- a/crates/intrinsic-test/src/x86/types.rs
+++ b/crates/intrinsic-test/src/x86/types.rs
@@ -3,12 +3,10 @@ use std::str::FromStr;
 use itertools::Itertools;
 
 use super::intrinsic::X86IntrinsicType;
-use crate::common::intrinsic_helpers::{
-    IntrinsicType, IntrinsicTypeDefinition, Sign, SimdLen, TypeKind,
-};
+use crate::common::intrinsic_helpers::{IntrinsicType, Sign, SimdLen, TypeDefinition, TypeKind};
 use crate::x86::xml_parser::Parameter;
 
-impl IntrinsicTypeDefinition for X86IntrinsicType {
+impl TypeDefinition for X86IntrinsicType {
     /// Gets a string containing the type in C format.
     /// This function assumes that this value is present in the metadata hashmap.
     fn c_type(&self) -> String {
diff --git a/crates/intrinsic-test/src/x86/xml_parser.rs b/crates/intrinsic-test/src/x86/xml_parser.rs
index 6006d7919f..f48a7bdfe5 100644
--- a/crates/intrinsic-test/src/x86/xml_parser.rs
+++ b/crates/intrinsic-test/src/x86/xml_parser.rs
@@ -1,6 +1,7 @@
 use crate::common::argument::{Argument, ArgumentList};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
+use crate::x86::X86;
 use crate::x86::constraint::map_constraints;
 
 use regex::Regex;
@@ -56,13 +57,13 @@ pub struct Parameter {
 
 pub fn get_xml_intrinsics(
     filename: &Path,
-) -> Result<Vec<Intrinsic<X86IntrinsicType>>, Box<dyn std::error::Error>> {
+) -> Result<Vec<Intrinsic<X86>>, Box<dyn std::error::Error>> {
     let file = std::fs::File::open(filename)?;
     let reader = std::io::BufReader::new(file);
     let data: Data =
         quick_xml::de::from_reader(reader).expect("failed to deserialize the source XML file");
 
-    let parsed_intrinsics: Vec<Intrinsic<X86IntrinsicType>> = data
+    let parsed_intrinsics: Vec<Intrinsic<X86>> = data
         .intrinsics
         .into_iter()
         .filter(|intrinsic| {
@@ -84,9 +85,7 @@ pub fn get_xml_intrinsics(
     Ok(parsed_intrinsics)
 }
 
-fn xml_to_intrinsic(
-    intr: XMLIntrinsic,
-) -> Result<Intrinsic<X86IntrinsicType>, Box<dyn std::error::Error>> {
+fn xml_to_intrinsic(intr: XMLIntrinsic) -> Result<Intrinsic<X86>, Box<dyn std::error::Error>> {
     let name = intr.name;
     let result = X86IntrinsicType::from_param(&intr.return_data);
     let args_check = intr.parameters.into_iter().enumerate().map(|(i, param)| {
@@ -100,12 +99,7 @@ fn xml_to_intrinsic(
                 param.imm_width
             };
             let constraint = map_constraints(&name, &param.imm_type, effective_imm_width);
-            let arg = Argument::<X86IntrinsicType>::new(
-                i,
-                param.var_name.clone(),
-                ty.unwrap(),
-                constraint,
-            );
+            let arg = Argument::<X86>::new(i, param.var_name.clone(), ty.unwrap(), constraint);
             Some(arg)
         }
     });
@@ -125,8 +119,8 @@ fn xml_to_intrinsic(
     // if one of the args has etype="MASK" and type="__m<int>d",
     // then set the bit_len and simd_len accordingly
     let re = Regex::new(r"__m\d+").unwrap();
-    let is_mask = |arg: &Argument<X86IntrinsicType>| arg.ty.param.etype.as_str() == "MASK";
-    let is_vector = |arg: &Argument<X86IntrinsicType>| re.is_match(arg.ty.param.type_data.as_str());
+    let is_mask = |arg: &Argument<X86>| arg.ty.param.etype.as_str() == "MASK";
+    let is_vector = |arg: &Argument<X86>| re.is_match(arg.ty.param.type_data.as_str());
     let pos = args_test.position(|arg| is_mask(arg) && is_vector(arg));
     if let Some(index) = pos {
         args[index].ty.bit_len = args[0].ty.bit_len;
@@ -134,7 +128,7 @@ fn xml_to_intrinsic(
 
     args.iter_mut().for_each(|arg| arg.ty.update_simd_len());
 
-    let arguments = ArgumentList::<X86IntrinsicType> { args };
+    let arguments = ArgumentList::<X86> { args };
 
     if let Err(message) = result {
         return Err(Box::from(message));