feat: code cleanup 1. changing array bracket prefixes from &'static str

to char 2. including variable names in template strings instead of
passing them as arguments to macros

Author: madhav-madhusoodanan

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

@@ -14,10 +14,10 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                 (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
+                (None, Some(_)) => todo!("{self:#?}"), // Likely an invalid case
             }
         } else {
-            todo!("{:#?}", self)
+            todo!("{self:#?}")
         }
     }
 
@@ -58,14 +58,14 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     // The ACLE doesn't support 64-bit polynomial loads on Armv7
                     // if armv7 and bl == 64, use "s", else "p"
                     TypeKind::Poly => if choose_workaround && *bl == 64 {"s"} else {"p"},
-                    x => todo!("get_load_function TypeKind: {:#?}", x),
+                    x => todo!("get_load_function TypeKind: {x:#?}"),
                 },
                 size = bl,
                 quad = quad,
                 len = vec_len.unwrap_or(1),
             )
         } else {
-            todo!("get_load_function IntrinsicType: {:#?}", self)
+            todo!("get_load_function IntrinsicType: {self:#?}")
         }
     }
 
@@ -90,13 +90,13 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     TypeKind::Int(Sign::Signed) => "s",
                     TypeKind::Float => "f",
                     TypeKind::Poly => "p",
-                    x => todo!("get_load_function TypeKind: {:#?}", x),
+                    x => todo!("get_load_function TypeKind: {x:#?}"),
                 },
                 size = bl,
                 quad = quad,
             )
         } else {
-            todo!("get_lane_function IntrinsicType: {:#?}", self)
+            todo!("get_lane_function IntrinsicType: {self:#?}")
         }
     }
 
@@ -143,7 +143,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     TypeKind::Int(Sign::Signed) => format!("int{}_t", self.inner_size()),
                     TypeKind::Int(Sign::Unsigned) => format!("uint{}_t", self.inner_size()),
                     TypeKind::Poly => format!("poly{}_t", self.inner_size()),
-                    ty => todo!("print_result_c - Unknown type: {:#?}", ty),
+                    ty => todo!("print_result_c - Unknown type: {ty:#?}"),
                 },
                 promote = self.generate_final_type_cast(),
             )

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

@@ -31,7 +31,7 @@ where
 
     pub fn to_c_type(&self) -> String {
         let prefix = if self.ty.constant { "const " } else { "" };
-        format!("{}{}", prefix, self.ty.c_type())
+        format!("{prefix}{}", self.ty.c_type())
     }
 
     pub fn generate_name(&self) -> String {

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

@@ -80,7 +80,7 @@ impl TypeKind {
             Self::Poly => "poly",
             Self::Char(Sign::Signed) => "char",
             Self::Vector => "int",
-            _ => unreachable!("Not used: {:#?}", self),
+            _ => unreachable!("Not used: {self:#?}"),
         }
     }
 
@@ -94,7 +94,7 @@ impl TypeKind {
             Self::Poly => "u",
             Self::Char(Sign::Unsigned) => "u",
             Self::Char(Sign::Signed) => "i",
-            _ => unreachable!("Unused type kind: {:#?}", self),
+            _ => unreachable!("Unused type kind: {self:#?}"),
         }
     }
 }
@@ -134,7 +134,7 @@ impl IntrinsicType {
         if let Some(bl) = self.bit_len {
             cmp::max(bl, 8)
         } else {
-            unreachable!("{:#?}", self)
+            unreachable!("{self:#?}")
         }
     }
 
@@ -225,8 +225,8 @@ impl IntrinsicType {
                 ..
             } => {
                 let (prefix, suffix) = match language {
-                    Language::Rust => ("[", "]"),
-                    Language::C => ("{", "}"),
+                    Language::Rust => ('[', ']'),
+                    Language::C => ('{', '}'),
                 };
                 let body_indentation = indentation.nested();
                 format!(
@@ -262,12 +262,12 @@ impl IntrinsicType {
                 ..
             } => {
                 let (prefix, cast_prefix, cast_suffix, suffix) = match (language, bit_len) {
-                    (&Language::Rust, 16) => ("[", "f16::from_bits(", ")", "]"),
-                    (&Language::Rust, 32) => ("[", "f32::from_bits(", ")", "]"),
-                    (&Language::Rust, 64) => ("[", "f64::from_bits(", ")", "]"),
-                    (&Language::C, 16) => ("{", "cast<float16_t, uint16_t>(", ")", "}"),
-                    (&Language::C, 32) => ("{", "cast<float, uint32_t>(", ")", "}"),
-                    (&Language::C, 64) => ("{", "cast<double, uint64_t>(", ")", "}"),
+                    (&Language::Rust, 16) => ('[', "f16::from_bits(", ")", ']'),
+                    (&Language::Rust, 32) => ('[', "f32::from_bits(", ")", ']'),
+                    (&Language::Rust, 64) => ('[', "f64::from_bits(", ")", ']'),
+                    (&Language::C, 16) => ('{', "cast<float16_t, uint16_t>(", ")", '}'),
+                    (&Language::C, 32) => ('{', "cast<float, uint32_t>(", ")", '}'),
+                    (&Language::C, 64) => ('{', "cast<double, uint64_t>(", ")", '}'),
                     _ => unreachable!(),
                 };
                 format!(
@@ -288,8 +288,8 @@ impl IntrinsicType {
                 ..
             } => {
                 let (prefix, suffix) = match language {
-                    Language::Rust => ("[", "]"),
-                    Language::C => ("{", "}"),
+                    Language::Rust => ('[', ']'),
+                    Language::C => ('{', '}'),
                 };
                 let body_indentation = indentation.nested();
                 let effective_bit_len = 32;
@@ -317,7 +317,7 @@ impl IntrinsicType {
                         })
                 )
             }
-            _ => unimplemented!("populate random: {:#?}", self),
+            _ => unimplemented!("populate random: {self:#?}"),
         }
     }
 

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

@@ -213,7 +213,7 @@ trait DebugAs<T> {
 
 impl<T: core::fmt::Display> DebugAs<T> for T {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self)
+        write!(f, "{self}")
     }
 }
 

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

@@ -219,11 +219,11 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
                     TypeKind::Float if self.inner_size() == 32 => "float".to_string(),
                     TypeKind::Mask => format!(
                         "__mmask{}",
-                        self.bit_len.expect(format!("self: {:#?}", self).as_str())
+                        self.bit_len.expect(format!("self: {self:#?}").as_str())
                     ),
                     TypeKind::Vector => format!(
                         "__m{}i",
-                        self.bit_len.expect(format!("self: {:#?}", self).as_str())
+                        self.bit_len.expect(format!("self: {self:#?}").as_str())
                     ),
                     _ => self.c_scalar_type(),
                 },