Recommend with_exposed_provenance instead of as casts in non-const

Author: Urgau

compiler/rustc_lint/src/lints.rs

@@ -1617,10 +1617,23 @@ pub(crate) struct IntegerToPtrTransmutes<'tcx> {
 }
 
 #[derive(Subdiagnostic)]
-// FIXME: recommend `with_exposed_provenance` when it's const-stable
+// FIXME: always recommend `with_exposed_provenance` when it's const-stable
 pub(crate) enum IntegerToPtrTransmutesSuggestion<'tcx> {
     #[multipart_suggestion(lint_suggestion_as, applicability = "machine-applicable")]
     ToPtr {
+        dst: Ty<'tcx>,
+        #[suggestion_part(code = "std::ptr::with_exposed_provenance::<{dst}>(")]
+        start_call: Span,
+    },
+    #[multipart_suggestion(lint_suggestion_as, applicability = "machine-applicable")]
+    ToRef {
+        dst: Ty<'tcx>,
+        ref_mutbl: &'static str,
+        #[suggestion_part(code = "&{ref_mutbl}*std::ptr::with_exposed_provenance::<{dst}>(")]
+        start_call: Span,
+    },
+    #[multipart_suggestion(lint_suggestion_as, applicability = "machine-applicable")]
+    ToPtrInConst {
         dst: Ty<'tcx>,
         paren_left: &'static str,
         paren_right: &'static str,
@@ -1630,7 +1643,7 @@ pub(crate) enum IntegerToPtrTransmutesSuggestion<'tcx> {
         end_call: Span,
     },
     #[multipart_suggestion(lint_suggestion_as, applicability = "machine-applicable")]
-    ToRef {
+    ToRefInConst {
         dst: Ty<'tcx>,
         ptr_mutbl: &'static str,
         ref_mutbl: &'static str,

compiler/rustc_lint/src/transmute.rs

@@ -165,23 +165,38 @@ fn check_int_to_ptr_transmute<'tcx>(
             expr.hir_id,
             expr.span,
             IntegerToPtrTransmutes {
-                suggestion: if dst.is_ref() {
-                    IntegerToPtrTransmutesSuggestion::ToRef {
-                        dst: *inner_ty,
-                        ref_mutbl: mutbl.prefix_str(),
-                        ptr_mutbl: mutbl.ptr_str(),
-                        paren_left,
-                        paren_right,
-                        start_call: expr.span.shrink_to_lo().until(arg.span),
-                        end_call: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
+                suggestion: if !cx.tcx.hir_is_inside_const_context(expr.hir_id) {
+                    if dst.is_ref() {
+                        IntegerToPtrTransmutesSuggestion::ToRef {
+                            dst: *inner_ty,
+                            ref_mutbl: mutbl.prefix_str(),
+                            start_call: expr.span.shrink_to_lo().until(arg.span),
+                        }
+                    } else {
+                        IntegerToPtrTransmutesSuggestion::ToPtr {
+                            dst: *inner_ty,
+                            start_call: expr.span.shrink_to_lo().until(arg.span),
+                        }
                     }
                 } else {
-                    IntegerToPtrTransmutesSuggestion::ToPtr {
-                        dst,
-                        paren_left,
-                        paren_right,
-                        start_call: expr.span.shrink_to_lo().until(arg.span),
-                        end_call: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
+                    if dst.is_ref() {
+                        IntegerToPtrTransmutesSuggestion::ToRefInConst {
+                            dst: *inner_ty,
+                            ref_mutbl: mutbl.prefix_str(),
+                            ptr_mutbl: mutbl.ptr_str(),
+                            paren_left,
+                            paren_right,
+                            start_call: expr.span.shrink_to_lo().until(arg.span),
+                            end_call: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
+                        }
+                    } else {
+                        IntegerToPtrTransmutesSuggestion::ToPtrInConst {
+                            dst,
+                            paren_left,
+                            paren_right,
+                            start_call: expr.span.shrink_to_lo().until(arg.span),
+                            end_call: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
+                        }
                     }
                 },
             },

tests/ui/lint/int_to_ptr.fixed

@@ -7,13 +7,13 @@
 #![allow(dead_code)]
 
 unsafe fn should_lint(a: usize) {
-    let _ptr = unsafe { a as *const u8 };
+    let _ptr = unsafe { std::ptr::with_exposed_provenance::<u8>(a) };
     //~^ WARN transmuting an integer to a pointer
-    let _ptr = unsafe { &*(a as *const u8) };
+    let _ptr = unsafe { &*std::ptr::with_exposed_provenance::<u8>(a) };
     //~^ WARN transmuting an integer to a pointer
-    let _ptr = unsafe { 42usize as *const u8 };
+    let _ptr = unsafe { std::ptr::with_exposed_provenance::<u8>(42usize) };
     //~^ WARN transmuting an integer to a pointer
-    let _ptr = unsafe { (a + a) as *const u8 };
+    let _ptr = unsafe { std::ptr::with_exposed_provenance::<u8>(a + a) };
     //~^ WARN transmuting an integer to a pointer
 }
 

tests/ui/lint/int_to_ptr.stderr

@@ -13,7 +13,7 @@ LL |     let _ptr = unsafe { std::mem::transmute::<usize, *const u8>(a) };
 help: use `as` cast instead to use a previously exposed provenance
    |
 LL -     let _ptr = unsafe { std::mem::transmute::<usize, *const u8>(a) };
-LL +     let _ptr = unsafe { a as *const u8 };
+LL +     let _ptr = unsafe { std::ptr::with_exposed_provenance::<u8>(a) };
    |
 
 warning: transmuting an integer to a pointer creates a pointer without provenance
@@ -30,7 +30,7 @@ LL |     let _ptr = unsafe { std::mem::transmute::<usize, &'static u8>(a) };
 help: use `as` cast instead to use a previously exposed provenance
    |
 LL -     let _ptr = unsafe { std::mem::transmute::<usize, &'static u8>(a) };
-LL +     let _ptr = unsafe { &*(a as *const u8) };
+LL +     let _ptr = unsafe { &*std::ptr::with_exposed_provenance::<u8>(a) };
    |
 
 warning: transmuting an integer to a pointer creates a pointer without provenance
@@ -47,7 +47,7 @@ LL |     let _ptr = unsafe { std::mem::transmute::<usize, *const u8>(42usize) };
 help: use `as` cast instead to use a previously exposed provenance
    |
 LL -     let _ptr = unsafe { std::mem::transmute::<usize, *const u8>(42usize) };
-LL +     let _ptr = unsafe { 42usize as *const u8 };
+LL +     let _ptr = unsafe { std::ptr::with_exposed_provenance::<u8>(42usize) };
    |
 
 warning: transmuting an integer to a pointer creates a pointer without provenance
@@ -64,7 +64,7 @@ LL |     let _ptr = unsafe { std::mem::transmute::<usize, *const u8>(a + a) };
 help: use `as` cast instead to use a previously exposed provenance
    |
 LL -     let _ptr = unsafe { std::mem::transmute::<usize, *const u8>(a + a) };
-LL +     let _ptr = unsafe { (a + a) as *const u8 };
+LL +     let _ptr = unsafe { std::ptr::with_exposed_provenance::<u8>(a + a) };
    |
 
 warning: transmuting an integer to a pointer creates a pointer without provenance