fixed union fields chain

Author: Kivooeo

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

@@ -297,25 +297,9 @@ impl<'db> UnsafeVisitor<'db> {
                         return;
                     }
                     Expr::Field { .. } => {
-                        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)
-                                    });
-                                }
-                            }
+                        if self.contains_union_field_access(*expr) {
+                            // Walk the entire field access chain without triggering union field errors
+                            self.walk_field_chain_for_raw_ptr(*expr);
                             return;
                         }
                     }
@@ -424,4 +408,43 @@ impl<'db> UnsafeVisitor<'db> {
             }
         }
     }
+
+    fn contains_union_field_access(&mut self, expr: ExprId) -> bool {
+        match &self.body.exprs[expr] {
+            Expr::Field { expr: base_expr, .. } => {
+                // Check if this field access is from a union
+                if matches!(
+                    self.infer.field_resolution(expr),
+                    Some(Either::Left(FieldId { parent: VariantId::UnionId(_), .. }))
+                ) {
+                    true
+                } else {
+                    // Recursively check the base expression
+                    self.contains_union_field_access(*base_expr)
+                }
+            }
+            _ => false,
+        }
+    }
+
+    /// Walks a field access chain for raw pointer creation, avoiding union field access errors
+    fn walk_field_chain_for_raw_ptr(&mut self, expr: ExprId) {
+        match &self.body.exprs[expr] {
+            Expr::Field { expr: base_expr, .. } => {
+                // First, recursively handle the base expression
+                self.walk_field_chain_for_raw_ptr(*base_expr);
+
+                // Then handle any non-field child expressions of this field access
+                self.body.walk_child_exprs_without_pats(expr, |child| {
+                    if child != *base_expr {
+                        self.walk_expr(child);
+                    }
+                });
+            }
+            _ => {
+                // We've reached the base expression (not a field access), walk it normally
+                self.walk_expr(expr);
+            }
+        }
+    }
 }

crates/ide-diagnostics/src/handlers/missing_unsafe.rs

@@ -869,6 +869,41 @@ fn main() {
         )
     }
 
+    #[test]
+    fn union_fields_chain_is_allowed() {
+        check_diagnostics(
+            r#"
+union Inner {
+    a: u8,
+}
+
+union MoreInner {
+    moreinner: ManuallyDrop<Inner>,
+}
+
+union LessOuter {
+    lessouter: ManuallyDrop<MoreInner>,
+}
+
+union Outer {
+    outer: ManuallyDrop<LessOuter>,
+}
+
+fn main() {
+    let super_outer = Outer {
+        outer: ManuallyDrop::new(LessOuter {
+            lessouter: ManuallyDrop::new(MoreInner {
+                moreinner: ManuallyDrop::new(Inner { a: 42 }),
+            }),
+        }),
+    };
+
+    let ptr = &raw const super_outer.outer.lessouter.moreinner.a;
+}
+"#,
+        );
+    }
+
     #[test]
     fn raw_ref_reborrow_is_safe() {
         check_diagnostics(