allow raw borrow on just union field access

Author: Kivooeo

1

@@ -0,0 +1,19 @@
+allow raw borrow on just union field access
+
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# Date:      Mon May 26 16:39:53 2025 +0500
+#
+# interactive rebase in progress; onto f98b6220c4
+# Last commands done (2 commands done):
+#    pick fb6416e94e allow raw borrow on just union field access
+#    squash 3be875810d temp
+# No commands remaining.
+# You are currently rebasing branch 'unsafegate' on 'f98b6220c4'.
+#
+# Changes to be committed:
+#	modified:   crates/hir-ty/src/diagnostics/unsafe_check.rs
+#	modified:   crates/ide-diagnostics/src/handlers/missing_unsafe.rs
+#	modified:   crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+#

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

@@ -296,6 +296,12 @@ impl<'db> UnsafeVisitor<'db> {
 
                         return;
                     }
+                    Expr::Field { .. } => {
+                        if self.is_union_field_access(*expr) {
+                            self.walk_union_field_for_raw_borrow(*expr);
+                            return;
+                        }
+                    }
                     _ => (),
                 }
             }
@@ -401,4 +407,31 @@ 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));
+            }
+        }
+    }
 }

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

@@ -834,6 +834,41 @@ fn bar(mut v: Union2) {
         )
     }
 
+    #[test]
+    fn raw_deref_on_union_field() {
+        check_diagnostics(
+            r#"
+fn main() {
+    union U1 {
+        a: u8
+    }
+    let x = U1 { a: 3 };
+
+    let a = x.a;
+         // ^^^ 💡 error: access to union field is unsafe and requires an unsafe function or block
+
+
+    let b = &raw const x.a;
+
+    let tmp = Vec::from([1, 2, 3]);
+
+    let c = &raw const tmp[x.a];
+                        // ^^^ 💡 error: access to union field is unsafe and requires an unsafe function or block
+
+    union URef {
+        p: &'static mut i32,
+    }
+
+    fn deref_union_field(u: URef) {
+        // Not an assignment but an access to the union field!
+        *(u.p) = 13;
+       // ^^^ 💡 error: access to union field is unsafe and requires an unsafe function or block
+    }
+}
+"#,
+        )
+    }
+
     #[test]
     fn raw_ref_reborrow_is_safe() {
         check_diagnostics(

crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html

@@ -96,7 +96,7 @@
 
         <span class="variable">u</span><span class="operator">.</span><span class="field unsafe">field</span><span class="semicolon">;</span>
         <span class="operator">&</span><span class="variable">u</span><span class="operator">.</span><span class="field unsafe">field</span><span class="semicolon">;</span>
-        <span class="operator">&</span><span class="keyword">raw</span> <span class="keyword const">const</span> <span class="variable">u</span><span class="operator">.</span><span class="field unsafe">field</span><span class="semicolon">;</span>
+        <span class="operator">&</span><span class="keyword">raw</span> <span class="keyword const">const</span> <span class="variable">u</span><span class="operator">.</span><span class="field">field</span><span class="semicolon">;</span>
         <span class="comment">// this should be safe!</span>
         <span class="keyword">let</span> <span class="union">Union</span> <span class="brace">{</span> <span class="field">field</span><span class="colon">:</span> <span class="punctuation">_</span> <span class="brace">}</span><span class="semicolon">;</span>
         <span class="comment">// but not these</span>