Apply cargo fmt to fix CI fmt --check on Vec::get_ref changes.

Author: Cod-e-Codes

src/cgen/builtins.rs

@@ -238,10 +238,15 @@ impl Codegen {
         // Vec::get_ref<T>(vec: &Vec<T>, index: int) -> Option<&T> (stack-local, no move-out)
         if callee == "Vec::get_ref" && args.len() == 2 {
             let option_name = return_type
-                .map(|t| mangle_type_name("Option", match t {
-                    Type::Generic { params, .. } => params.as_slice(),
-                    _ => &[],
-                }))
+                .map(|t| {
+                    mangle_type_name(
+                        "Option",
+                        match t {
+                            Type::Generic { params, .. } => params.as_slice(),
+                            _ => &[],
+                        },
+                    )
+                })
                 .unwrap_or_else(|| "Option_int_".to_string());
             let ref_c_type = return_type
                 .and_then(|t| {
@@ -269,16 +274,19 @@ impl Codegen {
             self.generate_expr(&args[1]);
             index_code = std::mem::replace(&mut self.output, old_output);
 
-            let elem_c_type = self.resolve_vec_elem_c_type(&args[0], return_type.and_then(|t| {
-                if let Type::Generic { params, .. } = t
-                    && params.len() == 1
-                    && let Type::Ref { inner, .. } = &params[0]
-                {
-                    Some(inner.as_ref())
-                } else {
-                    None
-                }
-            }));
+            let elem_c_type = self.resolve_vec_elem_c_type(
+                &args[0],
+                return_type.and_then(|t| {
+                    if let Type::Generic { params, .. } = t
+                        && params.len() == 1
+                        && let Type::Ref { inner, .. } = &params[0]
+                    {
+                        Some(inner.as_ref())
+                    } else {
+                        None
+                    }
+                }),
+            );
             let deref_vec = self.vec_ion_ptr_expr(&args[0], &vec_code);
 
             let mut code = String::new();
@@ -394,9 +402,9 @@ impl Codegen {
         // String::len(s: &String) -> int
         if callee == "String::len" && args.len() == 1 {
             let mut code = String::new();
-            let needs_deref = self
-                .infer_irexpr_type(&args[0])
-                .is_some_and(|ty| matches!(ty, Type::Ref { inner, .. } if matches!(*inner, Type::String)));
+            let needs_deref = self.infer_irexpr_type(&args[0]).is_some_and(
+                |ty| matches!(ty, Type::Ref { inner, .. } if matches!(*inner, Type::String)),
+            );
             if needs_deref {
                 code.push_str("((");
                 let mut arg_code = String::new();

src/cgen/mod.rs

@@ -3629,9 +3629,7 @@ impl Codegen {
 
             // Stack-local Option<&T> from Vec::get_ref is assigned directly.
             let returns_heap_option = if let Some(Type::Generic { name, params }) = return_type {
-                name == "Option"
-                    && params.len() == 1
-                    && !matches!(params[0], Type::Ref { .. })
+                name == "Option" && params.len() == 1 && !matches!(params[0], Type::Ref { .. })
             } else {
                 false
             };

src/tc/mod.rs

@@ -867,7 +867,9 @@ impl TypeChecker {
                     mutable: true,
                 }))
             }
-            ("Vec", "Vec::len") | ("Vec", "Vec::capacity") | ("Vec", "Vec::get")
+            ("Vec", "Vec::len")
+            | ("Vec", "Vec::capacity")
+            | ("Vec", "Vec::get")
             | ("Vec", "Vec::get_ref") => {
                 // These methods require &Vec<T>
                 let elem_type = match receiver_type {
@@ -2472,7 +2474,8 @@ impl TypeChecker {
                             Type::Struct(ref name) => {
                                 if self.is_type_param(name) {
                                     return Err(TypeCheckError::TypeMismatch {
-                                        expected: "concrete struct value for field access".to_string(),
+                                        expected: "concrete struct value for field access"
+                                            .to_string(),
                                         got: format!("type parameter '{}'", name),
                                         span: acc.span,
                                     });
@@ -2495,7 +2498,10 @@ impl TypeChecker {
                                     })?;
                                 field.ty.clone()
                             }
-                            Type::Generic { ref name, ref params } => {
+                            Type::Generic {
+                                ref name,
+                                ref params,
+                            } => {
                                 let decl = self.structs.get(name).ok_or_else(|| {
                                     TypeCheckError::TypeMismatch {
                                         expected: "known struct type".to_string(),
@@ -2534,12 +2540,13 @@ impl TypeChecker {
                                 }
                             },
                             Type::Tuple { ref elements } => {
-                                let index: usize =
-                                    acc.field.parse().map_err(|_| TypeCheckError::TypeMismatch {
+                                let index: usize = acc.field.parse().map_err(|_| {
+                                    TypeCheckError::TypeMismatch {
                                         expected: "numeric tuple field index".to_string(),
                                         got: acc.field.clone(),
                                         span: acc.span,
-                                    })?;
+                                    }
+                                })?;
                                 if index >= elements.len() {
                                     return Err(TypeCheckError::TypeMismatch {
                                         expected: format!(
@@ -2561,8 +2568,7 @@ impl TypeChecker {
                             }
                         };
                         if let Type::Struct(ref struct_name) = *inner
-                            && let Some(target) =
-                                self.lookup_field_target(struct_name, &acc.field)
+                            && let Some(target) = self.lookup_field_target(struct_name, &acc.field)
                         {
                             self.record_reference(acc.field_span, target);
                         }