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

Fixes rust-lang/rust-clippy#1966.

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) -> &i32 {
    unsafe { transmute(foo) }
}
```

changelog: [`transmute_ptr_to_ref`]: now checks for a pointer wrapped in
a struct

Author: Alexendoo

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,14 +545,17 @@ 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)
+                | transmute_ptr_to_ptr::check(cx, e, from_field_ty, to_ty, from_field_expr, self.msrv)
                 | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
                 | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
                 | (unsound_collection_transmute::check(cx, e, from_ty, to_ty)

clippy_lints/src/transmute/transmute_ptr_to_ptr.rs

@@ -14,11 +14,9 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    arg: &'tcx Expr<'_>,
+    arg: sugg::Sugg<'_>,
     msrv: Msrv,
 ) -> bool {
-    let mut applicability = Applicability::MachineApplicable;
-    let arg_sugg = sugg::Sugg::hir_with_context(cx, arg, e.span.ctxt(), "..", &mut applicability);
     match (from_ty.kind(), to_ty.kind()) {
         (ty::RawPtr(from_pointee_ty, from_mutbl), ty::RawPtr(to_pointee_ty, to_mutbl)) => {
             span_lint_and_then(
@@ -34,7 +32,7 @@ pub(super) fn check<'tcx>(
                         diag.span_suggestion_verbose(
                             e.span,
                             "use `pointer::cast` instead",
-                            format!("{}.cast::<{to_pointee_ty}>()", arg_sugg.maybe_paren()),
+                            format!("{}.cast::<{to_pointee_ty}>()", arg.maybe_paren()),
                             Applicability::MaybeIncorrect,
                         );
                     } else if from_pointee_ty == to_pointee_ty
@@ -49,14 +47,14 @@ pub(super) fn check<'tcx>(
                         diag.span_suggestion_verbose(
                             e.span,
                             format!("use `pointer::{method}` instead"),
-                            format!("{}.{method}()", arg_sugg.maybe_paren()),
+                            format!("{}.{method}()", arg.maybe_paren()),
                             Applicability::MaybeIncorrect,
                         );
                     } else {
                         diag.span_suggestion_verbose(
                             e.span,
                             "use an `as` cast instead",
-                            arg_sugg.as_ty(to_ty),
+                            arg.as_ty(to_ty),
                             Applicability::MaybeIncorrect,
                         );
                     }

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"),

tests/ui/transmute_ptr_to_ptr.fixed

@@ -24,6 +24,13 @@ struct GenericParam<T> {
     t: T,
 }
 
+#[derive(Clone, Copy)]
+struct PtrNamed {
+    ptr: *const u32,
+}
+#[derive(Clone, Copy)]
+struct Ptr(*const u32);
+
 fn transmute_ptr_to_ptr() {
     let ptr = &1u32 as *const u32;
     let mut_ptr = &mut 1u32 as *mut u32;
@@ -68,6 +75,18 @@ fn transmute_ptr_to_ptr() {
     let _: &GenericParam<&LifetimeParam<'static>> = unsafe { transmute(&GenericParam { t: &lp }) };
 }
 
+fn issue1966() {
+    let ptr = &1u32 as *const u32;
+    unsafe {
+        let _: *const f32 = Ptr(ptr).0.cast::<f32>();
+        //~^ transmute_ptr_to_ptr
+        let _: *const f32 = PtrNamed { ptr }.ptr.cast::<f32>();
+        //~^ transmute_ptr_to_ptr
+        let _: *mut u32 = Ptr(ptr).0.cast_mut();
+        //~^ transmute_ptr_to_ptr
+    }
+}
+
 fn lifetime_to_static(v: *mut &()) -> *const &'static () {
     unsafe { v as *const &() }
     //~^ transmute_ptr_to_ptr
@@ -81,11 +100,15 @@ const _: &() = {
     unsafe { transmute::<&'static Zst, &'static ()>(zst) }
 };
 
+#[derive(Clone, Copy)]
+struct Ptr8(*const u8);
 #[clippy::msrv = "1.37"]
 fn msrv_1_37(ptr: *const u8) {
     unsafe {
         let _: *const i8 = ptr as *const i8;
         //~^ transmute_ptr_to_ptr
+        let _: *const i8 = Ptr8(ptr).0 as *const i8;
+        //~^ transmute_ptr_to_ptr
     }
 }
 

tests/ui/transmute_ptr_to_ptr.rs

@@ -24,6 +24,13 @@ struct GenericParam<T> {
     t: T,
 }
 
+#[derive(Clone, Copy)]
+struct PtrNamed {
+    ptr: *const u32,
+}
+#[derive(Clone, Copy)]
+struct Ptr(*const u32);
+
 fn transmute_ptr_to_ptr() {
     let ptr = &1u32 as *const u32;
     let mut_ptr = &mut 1u32 as *mut u32;
@@ -68,6 +75,18 @@ fn transmute_ptr_to_ptr() {
     let _: &GenericParam<&LifetimeParam<'static>> = unsafe { transmute(&GenericParam { t: &lp }) };
 }
 
+fn issue1966() {
+    let ptr = &1u32 as *const u32;
+    unsafe {
+        let _: *const f32 = transmute(Ptr(ptr));
+        //~^ transmute_ptr_to_ptr
+        let _: *const f32 = transmute(PtrNamed { ptr });
+        //~^ transmute_ptr_to_ptr
+        let _: *mut u32 = transmute(Ptr(ptr));
+        //~^ transmute_ptr_to_ptr
+    }
+}
+
 fn lifetime_to_static(v: *mut &()) -> *const &'static () {
     unsafe { transmute(v) }
     //~^ transmute_ptr_to_ptr
@@ -81,11 +100,15 @@ const _: &() = {
     unsafe { transmute::<&'static Zst, &'static ()>(zst) }
 };
 
+#[derive(Clone, Copy)]
+struct Ptr8(*const u8);
 #[clippy::msrv = "1.37"]
 fn msrv_1_37(ptr: *const u8) {
     unsafe {
         let _: *const i8 = transmute(ptr);
         //~^ transmute_ptr_to_ptr
+        let _: *const i8 = transmute(Ptr8(ptr));
+        //~^ transmute_ptr_to_ptr
     }
 }