feat(transmute_ptr_to_ref): Handle a pointer wrapped in a struct

ceptontech · ceptontech · commit 5ac265676a6a · 2025-12-01T10:12:36.000-08:00
Now the program checks for transmutting from a struct containing a
single raw pointer to a reference.

```Rust
struct Foo(*const i32);
fn foo(foo: Foo) -&gt; &amp;i32 {
    unsafe { transmute(foo) }
}
```

changelog: [`transmute_ptr_to_ref`]: now checks for a pointer wrapped in
a struct
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
@@ -18,8 +18,11 @@ mod wrong_transmute;
 use clippy_config::Conf;
 use clippy_utils::is_in_const_context;
 use clippy_utils::msrvs::Msrv;
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 
@@ -490,6 +493,32 @@ impl Transmute {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
     }
+
+    /// When transmuting, a struct containing a single field works like the field.
+    /// This function extracts the field type and the expression to get the field.
+    fn extract_struct_field<'tcx>(
+        cx: &LateContext<'tcx>,
+        e: &'tcx Expr<'_>,
+        outer_type: Ty<'tcx>,
+        outer: &'tcx Expr<'tcx>,
+    ) -> (Ty<'tcx>, Sugg<'tcx>) {
+        let mut applicability = Applicability::MachineApplicable;
+        let outer_sugg = Sugg::hir_with_context(cx, outer, e.span.ctxt(), "..", &mut applicability);
+        if let ty::Adt(struct_def, struct_args) = *outer_type.kind()
+            && struct_def.is_struct()
+            && let mut fields = struct_def.all_fields()
+            && let Some(first) = fields.next()
+            && fields.next().is_none()
+            && first.vis.is_accessible_from(cx.tcx.parent_module(outer.hir_id), cx.tcx)
+        {
+            (
+                first.ty(cx.tcx, struct_args),
+                Sugg::NonParen(format!("{}.{}", outer_sugg.maybe_paren(), first.name).into()),
+            )
+        } else {
+            (outer_type, outer_sugg)
+        }
+    }
 }
 impl<'tcx> LateLintPass<'tcx> for Transmute {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
@@ -516,11 +545,14 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 return;
             }
 
+            // A struct having a single pointer can be treated like a pointer.
+            let (from_field_ty, from_field_expr) = Self::extract_struct_field(cx, e, from_ty, arg);
+
             let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
                 | crosspointer_transmute::check(cx, e, from_ty, to_ty)
                 | transmuting_null::check(cx, e, arg, to_ty)
                 | transmute_null_to_fn::check(cx, e, arg, to_ty)
-                | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
+                | transmute_ptr_to_ref::check(cx, e, from_field_ty, to_ty, from_field_expr.clone(), path, self.msrv)
                 | missing_transmute_annotations::check(cx, path, arg, from_ty, to_ty, e.hir_id)
                 | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
                 | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, self.msrv)
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    arg: &'tcx Expr<'_>,
+    arg: sugg::Sugg<'_>,
     path: &'tcx Path<'_>,
     msrv: Msrv,
 ) -> bool {
@@ -27,7 +27,6 @@ pub(super) fn check<'tcx>(
                 e.span,
                 format!("transmute from a pointer type (`{from_ty}`) to a reference type (`{to_ty}`)"),
                 |diag| {
-                    let arg = sugg::Sugg::hir(cx, arg, "..");
                     let (deref, cast) = match mutbl {
                         Mutability::Mut => ("&mut *", "*mut"),
                         Mutability::Not => ("&*", "*const"),
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
@@ -55,6 +55,52 @@ fn issue1231() {
     //~^ transmute_ptr_to_ref
 }
 
+#[derive(Clone, Copy)]
+struct PtrRefNamed<'a> {
+    ptr: *const &'a u32,
+}
+#[derive(Clone, Copy)]
+struct PtrRef<'a>(*const &'a u32);
+#[derive(Clone, Copy)]
+struct PtrSliceRef<'a>(*const [&'a str]);
+#[derive(Clone, Copy)]
+struct PtrSlice(*const [i32]);
+#[derive(Clone, Copy)]
+struct Ptr(*const u32);
+impl std::ops::Add for Ptr {
+    type Output = Self;
+    fn add(self, _: Self) -> Self {
+        self
+    }
+}
+mod ptr_mod {
+    #[derive(Clone, Copy)]
+    pub struct Ptr(*const u32);
+}
+fn issue1966(u: PtrSlice, v: PtrSliceRef, w: Ptr, x: PtrRefNamed, y: PtrRef, z: ptr_mod::Ptr) {
+    unsafe {
+        let _: &i32 = &*(w.0 as *const i32);
+        //~^ transmute_ptr_to_ref
+        let _: &u32 = &*w.0;
+        //~^ transmute_ptr_to_ref
+        let _: &&u32 = &*x.ptr.cast::<&u32>();
+        //~^ transmute_ptr_to_ref
+        // The field is not accessible. The program should not generate code
+        // that accesses the field.
+        let _: &u32 = std::mem::transmute(z);
+        let _ = &*w.0.cast::<u32>();
+        //~^ transmute_ptr_to_ref
+        let _: &[&str] = &*(v.0 as *const [&str]);
+        //~^ transmute_ptr_to_ref
+        let _ = &*(u.0 as *const [i32]);
+        //~^ transmute_ptr_to_ref
+        let _: &&u32 = &*y.0.cast::<&u32>();
+        //~^ transmute_ptr_to_ref
+        let _: &u32 = &*(w + w).0;
+        //~^ transmute_ptr_to_ref
+    }
+}
+
 fn issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     unsafe {
         match 0 {
@@ -89,18 +135,24 @@ fn meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
 }
 
 #[clippy::msrv = "1.37"]
-fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn under_msrv<'a, 'b, 'c>(x: *const &'a u32, y: PtrRef) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
         let _: &u32 = &*a;
         //~^ transmute_ptr_to_ref
         let _: &u32 = &*(a as *const u32);
         //~^ transmute_ptr_to_ref
+        let _ = &*(Ptr(a).0 as *const u32);
+        //~^ transmute_ptr_to_ref
         match 0 {
             0 => &*(x as *const () as *const &u32),
             //~^ transmute_ptr_to_ref
-            _ => &*(x as *const () as *const &'b u32),
+            1 => &*(x as *const () as *const &'b u32),
+            //~^ transmute_ptr_to_ref
+            2 => &*(y.0 as *const () as *const &u32),
+            //~^ transmute_ptr_to_ref
+            _ => &*(y.0 as *const () as *const &'b u32),
             //~^ transmute_ptr_to_ref
         }
     }
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
@@ -55,6 +55,52 @@ fn issue1231() {
     //~^ transmute_ptr_to_ref
 }
 
+#[derive(Clone, Copy)]
+struct PtrRefNamed<'a> {
+    ptr: *const &'a u32,
+}
+#[derive(Clone, Copy)]
+struct PtrRef<'a>(*const &'a u32);
+#[derive(Clone, Copy)]
+struct PtrSliceRef<'a>(*const [&'a str]);
+#[derive(Clone, Copy)]
+struct PtrSlice(*const [i32]);
+#[derive(Clone, Copy)]
+struct Ptr(*const u32);
+impl std::ops::Add for Ptr {
+    type Output = Self;
+    fn add(self, _: Self) -> Self {
+        self
+    }
+}
+mod ptr_mod {
+    #[derive(Clone, Copy)]
+    pub struct Ptr(*const u32);
+}
+fn issue1966(u: PtrSlice, v: PtrSliceRef, w: Ptr, x: PtrRefNamed, y: PtrRef, z: ptr_mod::Ptr) {
+    unsafe {
+        let _: &i32 = std::mem::transmute(w);
+        //~^ transmute_ptr_to_ref
+        let _: &u32 = std::mem::transmute(w);
+        //~^ transmute_ptr_to_ref
+        let _: &&u32 = core::mem::transmute(x);
+        //~^ transmute_ptr_to_ref
+        // The field is not accessible. The program should not generate code
+        // that accesses the field.
+        let _: &u32 = std::mem::transmute(z);
+        let _ = std::mem::transmute::<_, &u32>(w);
+        //~^ transmute_ptr_to_ref
+        let _: &[&str] = core::mem::transmute(v);
+        //~^ transmute_ptr_to_ref
+        let _ = std::mem::transmute::<_, &[i32]>(u);
+        //~^ transmute_ptr_to_ref
+        let _: &&u32 = std::mem::transmute(y);
+        //~^ transmute_ptr_to_ref
+        let _: &u32 = std::mem::transmute(w + w);
+        //~^ transmute_ptr_to_ref
+    }
+}
+
 fn issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     unsafe {
         match 0 {
@@ -89,18 +135,24 @@ fn meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
 }
 
 #[clippy::msrv = "1.37"]
-fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn under_msrv<'a, 'b, 'c>(x: *const &'a u32, y: PtrRef) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
         let _: &u32 = std::mem::transmute(a);
         //~^ transmute_ptr_to_ref
         let _: &u32 = std::mem::transmute::<_, &u32>(a);
         //~^ transmute_ptr_to_ref
+        let _ = std::mem::transmute::<_, &u32>(Ptr(a));
+        //~^ transmute_ptr_to_ref
         match 0 {
             0 => std::mem::transmute(x),
             //~^ transmute_ptr_to_ref
-            _ => std::mem::transmute::<_, &&'b u32>(x),
+            1 => std::mem::transmute::<_, &&'b u32>(x),
+            //~^ transmute_ptr_to_ref
+            2 => std::mem::transmute(y),
+            //~^ transmute_ptr_to_ref
+            _ => std::mem::transmute::<_, &&'b u32>(y),
             //~^ transmute_ptr_to_ref
         }
     }
diff --git a/tests/ui/transmute_ptr_to_ref.stderr b/tests/ui/transmute_ptr_to_ref.stderr
