style:Refactor vector instruction handling in Cranelift backend tests for improved readability

- Reformatted code for creating vector instructions to enhance clarity.
- Adjusted formatting of terminator settings for consistency.
- Improved readability of function calls by breaking lines for better alignment.
- Ensured consistent use of block structure in test functions.
- Minor adjustments to comments for clarity.

Update ZyntaxRuntime type registration logic for better clarity

- Refactored type registration logic to improve readability.
- Simplified the existing ID check for registered types.
- Enhanced the flow of logic when checking for existing types with fields.

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -622,7 +622,6 @@ pub enum HirInstruction {
     // ========================================================================
     // SIMD / Vector Instructions
     // ========================================================================
-
     /// Broadcast a scalar value to all lanes of a SIMD vector.
     ///
     /// `ty` must be `HirType::Vector(elem_ty, lanes)`.

crates/compiler/src/hir.rs

@@ -924,23 +924,63 @@ fn fmt_instruction(inst: &HirInstruction, mapper: &mut IdMapper) -> String {
             let s = mapper.value(scalar);
             format!("{}: {} = vector_splat {}", r, fmt_type(ty), s)
         }
-        HirInstruction::VectorExtractLane { result, ty, vector, lane } => {
+        HirInstruction::VectorExtractLane {
+            result,
+            ty,
+            vector,
+            lane,
+        } => {
             let r = mapper.value(result);
             let v = mapper.value(vector);
-            format!("{}: {} = extract_lane {}, lane {}", r, fmt_type(ty), v, lane)
+            format!(
+                "{}: {} = extract_lane {}, lane {}",
+                r,
+                fmt_type(ty),
+                v,
+                lane
+            )
         }
-        HirInstruction::VectorInsertLane { result, ty, vector, scalar, lane } => {
+        HirInstruction::VectorInsertLane {
+            result,
+            ty,
+            vector,
+            scalar,
+            lane,
+        } => {
             let r = mapper.value(result);
             let v = mapper.value(vector);
             let s = mapper.value(scalar);
-            format!("{}: {} = insert_lane {}, lane {}, {}", r, fmt_type(ty), v, lane, s)
+            format!(
+                "{}: {} = insert_lane {}, lane {}, {}",
+                r,
+                fmt_type(ty),
+                v,
+                lane,
+                s
+            )
         }
-        HirInstruction::VectorHorizontalReduce { result, ty, vector, op } => {
+        HirInstruction::VectorHorizontalReduce {
+            result,
+            ty,
+            vector,
+            op,
+        } => {
             let r = mapper.value(result);
             let v = mapper.value(vector);
-            format!("{}: {} = hreduce.{} {}", r, fmt_type(ty), fmt_binary_op(op), v)
+            format!(
+                "{}: {} = hreduce.{} {}",
+                r,
+                fmt_type(ty),
+                fmt_binary_op(op),
+                v
+            )
         }
-        HirInstruction::VectorLoad { result, ty, ptr, align } => {
+        HirInstruction::VectorLoad {
+            result,
+            ty,
+            ptr,
+            align,
+        } => {
             let r = mapper.value(result);
             let p = mapper.value(ptr);
             format!("{}: {} = vload {}, align {}", r, fmt_type(ty), p, align)

crates/compiler/src/hir_dump.rs

@@ -1181,16 +1181,17 @@ impl LoweringContext {
                     } = &receiver_type
                     {
                         // Also get the type name for matching extern impls
-                        let receiver_type_name = self.type_registry
+                        let receiver_type_name = self
+                            .type_registry
                             .get_type_by_id(*receiver_type_id)
                             .map(|td| td.name);
                         // Look up the trait implementation
                         for (_trait_id, impls) in self.type_registry.iter_implementations() {
                             for impl_def in impls {
                                 let impl_matches = match &impl_def.for_type {
-                                    Type::Named { id: impl_type_id, .. } => {
-                                        *impl_type_id == *receiver_type_id
-                                    }
+                                    Type::Named {
+                                        id: impl_type_id, ..
+                                    } => *impl_type_id == *receiver_type_id,
                                     Type::Extern { name, .. } => {
                                         receiver_type_name.map_or(false, |n| n == *name)
                                     }
@@ -1212,7 +1213,9 @@ impl LoweringContext {
                         }
                         // Also check inherent methods on the type definition (for extern struct methods)
                         if matches!(expr.ty, Type::Any | Type::Unknown) {
-                            if let Some(type_def) = self.type_registry.get_type_by_id(*receiver_type_id) {
+                            if let Some(type_def) =
+                                self.type_registry.get_type_by_id(*receiver_type_id)
+                            {
                                 for method in &type_def.methods {
                                     if method.name == method_call.method {
                                         expr.ty = method.return_type.clone();
@@ -1221,7 +1224,10 @@ impl LoweringContext {
                                 }
                             }
                         }
-                    } else if let Type::Extern { name: extern_name, .. } = &receiver_type {
+                    } else if let Type::Extern {
+                        name: extern_name, ..
+                    } = &receiver_type
+                    {
                         // Look up methods in impl blocks for extern types (e.g., Tensor)
                         // This enables chained method calls like t.reshape([2,3]).transpose()
                         for (_trait_id, impls) in self.type_registry.iter_implementations() {
@@ -1243,7 +1249,9 @@ impl LoweringContext {
                         }
                         // Also check inherent methods on the type definition
                         if matches!(expr.ty, Type::Any | Type::Unknown) {
-                            if let Some(type_def) = self.type_registry.get_type_by_name(*extern_name) {
+                            if let Some(type_def) =
+                                self.type_registry.get_type_by_name(*extern_name)
+                            {
                                 for method in &type_def.methods {
                                     if method.name == method_call.method {
                                         expr.ty = method.return_type.clone();