temp

Author: Kivooeo

crates/hir-ty/src/diagnostics/unsafe_check.rs

@@ -297,8 +297,25 @@ impl<'db> UnsafeVisitor<'db> {
                         return;
                     }
                     Expr::Field { .. } => {
-                        if self.is_union_field_access(*expr) {
-                            self.walk_union_field_for_raw_borrow(*expr);
+                        if matches!(
+                            self.infer.field_resolution(*expr),
+                            Some(Either::Left(FieldId { parent: VariantId::UnionId(_), .. }))
+                        ) {
+                            match &self.body.exprs[*expr] {
+                                Expr::Field { expr, .. } => {
+                                    // Visit the base expression (e.g., `self` in `self.field`) for safety,
+                                    // but don't trigger the union field access error since we're just
+                                    // creating a raw pointer, not actually reading the field
+                                    self.walk_expr(*expr);
+                                }
+                                _ => {
+                                    self.body.walk_child_exprs_without_pats(*expr, |child| {
+                                        // If it's not a field access for some reason, fall back to normal walking
+                                        // This shouldn't happen based on how this function is called
+                                        self.walk_expr(child)
+                                    });
+                                }
+                            }
                             return;
                         }
                     }
@@ -407,31 +424,4 @@ impl<'db> UnsafeVisitor<'db> {
             }
         }
     }
-
-    /// Check if an expression is accessing a union field
-    fn is_union_field_access(&self, expr_id: ExprId) -> bool {
-        matches!(
-            self.infer.field_resolution(expr_id),
-            Some(Either::Left(FieldId { parent: VariantId::UnionId(_), .. }))
-        )
-    }
-
-    /// Visit a union field access in the context of creating a raw reference
-    /// This ensures we check safety of the base expression while allowing
-    /// the raw pointer creation to the union field itself
-    fn walk_union_field_for_raw_borrow(&mut self, expr_id: ExprId) {
-        match &self.body.exprs[expr_id] {
-            Expr::Field { expr, .. } => {
-                // Visit the base expression (e.g., `self` in `self.field`) for safety,
-                // but don't trigger the union field access error since we're just
-                // creating a raw pointer, not actually reading the field
-                self.walk_expr(*expr);
-            }
-            _ => {
-                // If it's not a field access for some reason, fall back to normal walking
-                // This shouldn't happen based on how this function is called
-                self.body.walk_child_exprs_without_pats(expr_id, |child| self.walk_expr(child));
-            }
-        }
-    }
 }