feat: fetching c_type representation from IntrinsicType's hashmap directly instead of

constructing it.

Further details:
1. moved "type_and_name_from_c" from Argument<T> to
Argument<ArmIntrinsicType>
2. removed "from_c" in Argument<T>

Author: madhav-madhusoodanan

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

@@ -0,0 +1,12 @@
+use crate::arm::intrinsic::ArmIntrinsicType;
+use crate::common::argument::Argument;
+
+impl Argument<ArmIntrinsicType> {
+    pub fn type_and_name_from_c(arg: &str) -> (&str, &str) {
+        let split_index = arg
+            .rfind([' ', '*'])
+            .expect("Couldn't split type and argname");
+
+        (arg[..split_index + 1].trim_end(), &arg[split_index + 1..])
+    }
+}

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

@@ -86,13 +86,17 @@ fn json_to_intrinsic(
         .into_iter()
         .enumerate()
         .map(|(i, arg)| {
-            let arg_name = Argument::<ArmIntrinsicType>::type_and_name_from_c(&arg).1;
-            let metadata = intr.args_prep.as_mut();
-            let metadata = metadata.and_then(|a| a.remove(arg_name));
-            let arg_prep: Option<ArgPrep> = metadata.and_then(|a| a.try_into().ok());
+            let (type_name, arg_name) = Argument::<ArmIntrinsicType>::type_and_name_from_c(&arg);
+            let ty = ArmIntrinsicType::from_c(type_name)
+                .unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
+
+            let arg_prep = intr.args_prep.as_mut();
+            let arg_prep = arg_prep.and_then(|a| a.remove(arg_name));
+            let arg_prep: Option<ArgPrep> = arg_prep.and_then(|a| a.try_into().ok());
             let constraint: Option<Constraint> = arg_prep.and_then(|a| a.try_into().ok());
 
-            let mut arg = Argument::<ArmIntrinsicType>::from_c(i, &arg, constraint);
+            let mut arg =
+                Argument::<ArmIntrinsicType>::new(i, arg_name.to_string(), ty, constraint);
             arg.ty
                 .set_metadata("target".to_string(), target.to_string());
 

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

@@ -1,3 +1,4 @@
+mod argument;
 mod compile;
 mod config;
 mod intrinsic;

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

@@ -6,22 +6,13 @@ use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, T
 
 impl IntrinsicTypeDefinition for ArmIntrinsicType {
     /// Gets a string containing the typename for this type in C format.
+    /// This assumes that the metadata hashmap contains this value at the
+    /// "type" key
     fn c_type(&self) -> String {
-        let prefix = self.0.kind.c_prefix();
-        let const_prefix = if self.0.constant { "const " } else { "" };
-
-        if let (Some(bit_len), simd_len, vec_len) =
-            (self.0.bit_len, self.0.simd_len, self.0.vec_len)
-        {
-            match (simd_len, vec_len) {
-                (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 {
-            todo!("{:#?}", self)
-        }
+        self.metadata
+            .get("type")
+            .expect("Failed to extract the C typename in Aarch!")
+            .to_string()
     }
 
     fn c_single_vector_type(&self) -> String {
@@ -129,6 +120,8 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
 
     fn from_c(s: &str) -> Result<Self, String> {
         const CONST_STR: &str = "const";
+        let mut metadata: HashMap<String, String> = HashMap::new();
+        metadata.insert("type".to_string(), s.to_string());
         if let Some(s) = s.strip_suffix('*') {
             let (s, constant) = match s.trim().strip_suffix(CONST_STR) {
                 Some(stripped) => (stripped, true),
@@ -176,7 +169,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     bit_len: Some(bit_len),
                     simd_len,
                     vec_len,
-                    metadata: HashMap::new(),
+                    metadata,
                 }))
             } else {
                 let kind = start.parse::<TypeKind>()?;
@@ -192,7 +185,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     bit_len,
                     simd_len: None,
                     vec_len: None,
-                    metadata: HashMap::new(),
+                    metadata,
                 }))
             }
         }

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

@@ -45,14 +45,6 @@ where
         self.constraint.is_some()
     }
 
-    pub fn type_and_name_from_c(arg: &str) -> (&str, &str) {
-        let split_index = arg
-            .rfind([' ', '*'])
-            .expect("Couldn't split type and argname");
-
-        (arg[..split_index + 1].trim_end(), &arg[split_index + 1..])
-    }
-
     /// The binding keyword (e.g. "const" or "let") for the array of possible test inputs.
     fn rust_vals_array_binding(&self) -> impl std::fmt::Display {
         if self.ty.is_rust_vals_array_const() {
@@ -71,19 +63,6 @@ where
         }
     }
 
-    pub fn from_c(pos: usize, arg: &str, constraint: Option<Constraint>) -> Argument<T> {
-        let (ty, var_name) = Self::type_and_name_from_c(arg);
-
-        let ty = T::from_c(ty).unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
-
-        Argument {
-            pos,
-            name: String::from(var_name),
-            ty: ty,
-            constraint,
-        }
-    }
-
     fn as_call_param_c(&self) -> String {
         self.ty.as_call_param_c(&self.name)
     }

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

@@ -8,17 +8,13 @@ use crate::common::cli::Language;
 use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, TypeKind};
 
 impl IntrinsicTypeDefinition for X86IntrinsicType {
-    /// Gets a string containing the typename for this type in C format.
+    /// 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 {
-        let part_0 = if self.constant { "const" } else { "" };
-        let part_1 = match self.kind {
-            TypeKind::Int(false) => "unsigned int",
-            TypeKind::Char(false) => "unsigned char",
-            _ => self.kind.c_prefix(),
-        };
-        let part_2 = if self.ptr { "*" } else { "" };
-
-        String::from(vec![part_0, part_1, part_2].join(" ").trim())
+        self.metadata
+            .get("type")
+            .expect("Failed to extract the C typename in X86!")
+            .to_string()
     }
 
     fn c_single_vector_type(&self) -> String {
@@ -41,6 +37,8 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
 
     fn from_c(s: &str) -> Result<Self, String> {
         let mut s_copy = s.to_string();
+        let mut metadata: HashMap<String, String> = HashMap::new();
+        metadata.insert("type".to_string(), s.to_string());
         s_copy = s_copy
             .replace("*", "")
             .replace("_", "")
@@ -80,7 +78,7 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
             bit_len: None,
             simd_len: None,
             vec_len: None,
-            metadata: HashMap::new(),
+            metadata,
         }))
     }
 }