Fix clippy::ref_as_ptr for non-temporary references in let/const

Author: Abd002

clippy_lints/src/casts/ref_as_ptr.rs

@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{ExprUseNode, expr_use_ctxt, std_or_core};
+use clippy_utils::{is_expr_temporary_value, std_or_core};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, Mutability, Ty, TyKind};
+use rustc_hir::{Expr, ExprKind, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 
@@ -22,11 +22,17 @@ pub(super) fn check<'tcx>(
 
     if matches!(cast_from.kind(), ty::Ref(..))
         && let ty::RawPtr(_, to_mutbl) = cast_to.kind()
-        && let use_cx = expr_use_ctxt(cx, expr)
-        // TODO: only block the lint if `cast_expr` is a temporary
-        && !matches!(use_cx.use_node(cx), ExprUseNode::LetStmt(_) | ExprUseNode::ConstStatic(_))
         && let Some(std_or_core) = std_or_core(cx)
     {
+        if let ExprKind::AddrOf(_, _, addr_inner) = cast_expr.kind
+            && is_expr_temporary_value(cx, addr_inner)
+        {
+            // This IS the dangerous case. Let the lint proceed.
+        } else {
+            // This is a safe, long-lived reference (e.g., &x, &static).
+            // The lint is unnecessary, so we return early.
+            return;
+        }
         let fn_name = match to_mutbl {
             Mutability::Not => "from_ref",
             Mutability::Mut => "from_mut",

tests/ui/ref_as_ptr.fixed

@@ -53,31 +53,21 @@ fn main() {
     //~^ ref_as_ptr
 
     let val = 1;
-    f(std::ptr::from_ref(&val));
-    //~^ ref_as_ptr
-    f(std::ptr::from_ref::<i32>(&val));
-    //~^ ref_as_ptr
+    f(&val as *const _);
+    f(&val as *const i32);
 
-    f(std::ptr::from_ref(&val) as *const f32);
-    //~^ ref_as_ptr
-    f(std::ptr::from_ref::<i32>(&val) as *const f64);
-    //~^ ref_as_ptr
+    f(&val as *const _ as *const f32);
+    f(&val as *const i32 as *const f64);
 
     let mut val: u8 = 2;
-    f(std::ptr::from_mut::<u8>(&mut val));
-    //~^ ref_as_ptr
-    f(std::ptr::from_mut(&mut val));
-    //~^ ref_as_ptr
+    f(&mut val as *mut u8);
+    f(&mut val as *mut _);
 
-    f(std::ptr::from_ref::<u8>(&mut val));
-    //~^ ref_as_ptr
-    f(std::ptr::from_ref(&mut val));
-    //~^ ref_as_ptr
+    f(&mut val as *const u8);
+    f(&mut val as *const _);
 
-    f(std::ptr::from_ref::<u8>(&mut val) as *const f64);
-    //~^ ref_as_ptr
-    f::<*const Option<u8>>(std::ptr::from_ref(&mut val) as *const _);
-    //~^ ref_as_ptr
+    f(&mut val as *const u8 as *const f64);
+    f::<*const Option<u8>>(&mut val as *const _ as *const _);
 
     f(std::ptr::from_ref::<[usize; 7]>(&std::array::from_fn(|i| i * i)));
     //~^ ref_as_ptr
@@ -86,9 +76,10 @@ fn main() {
     f(std::ptr::from_mut::<[usize; 9]>(&mut std::array::from_fn(|i| i * i)));
     //~^ ref_as_ptr
 
-    let _ = &String::new() as *const _;
-    let _ = &mut String::new() as *mut _;
-    const FOO: *const String = &String::new() as *const _;
+    let _ = std::ptr::from_ref(&String::new());
+    //~^ ref_as_ptr
+    let _ = std::ptr::from_mut(&mut String::new());
+    //~^ ref_as_ptr
 }
 
 #[clippy::msrv = "1.75"]
@@ -106,55 +97,44 @@ fn _msrv_1_76() {
     let val = &42_i32;
     let mut_val = &mut 42_i32;
 
-    f(std::ptr::from_ref::<i32>(val));
-    //~^ ref_as_ptr
-    f(std::ptr::from_mut::<i32>(mut_val));
-    //~^ ref_as_ptr
+    f(val as *const i32);
+    f(mut_val as *mut i32);
 }
 
 fn foo(val: &[u8]) {
-    f(std::ptr::from_ref(val));
-    //~^ ref_as_ptr
-    f(std::ptr::from_ref::<[u8]>(val));
-    //~^ ref_as_ptr
+    f(val as *const _);
+    f(val as *const [u8]);
 }
 
 fn bar(val: &mut str) {
-    f(std::ptr::from_mut(val));
-    //~^ ref_as_ptr
-    f(std::ptr::from_mut::<str>(val));
-    //~^ ref_as_ptr
+    f(val as *mut _);
+    f(val as *mut str);
 }
 
 struct X<'a>(&'a i32);
 
 impl<'a> X<'a> {
     fn foo(&self) -> *const i64 {
-        std::ptr::from_ref(self.0) as *const _
-        //~^ ref_as_ptr
+        self.0 as *const _ as *const _
     }
 
     fn bar(&mut self) -> *const i64 {
-        std::ptr::from_ref(self.0) as *const _
-        //~^ ref_as_ptr
+        self.0 as *const _ as *const _
     }
 }
 
 struct Y<'a>(&'a mut i32);
 
 impl<'a> Y<'a> {
     fn foo(&self) -> *const i64 {
-        std::ptr::from_ref(self.0) as *const _
-        //~^ ref_as_ptr
+        self.0 as *const _ as *const _
     }
 
     fn bar(&mut self) -> *const i64 {
-        std::ptr::from_ref(self.0) as *const _
-        //~^ ref_as_ptr
+        self.0 as *const _ as *const _
     }
 
     fn baz(&mut self) -> *const i64 {
-        std::ptr::from_mut(self.0) as *mut _
-        //~^ ref_as_ptr
+        self.0 as *mut _ as *mut _
     }
 }

tests/ui/ref_as_ptr.rs

@@ -54,30 +54,20 @@ fn main() {
 
     let val = 1;
     f(&val as *const _);
-    //~^ ref_as_ptr
     f(&val as *const i32);
-    //~^ ref_as_ptr
 
     f(&val as *const _ as *const f32);
-    //~^ ref_as_ptr
     f(&val as *const i32 as *const f64);
-    //~^ ref_as_ptr
 
     let mut val: u8 = 2;
     f(&mut val as *mut u8);
-    //~^ ref_as_ptr
     f(&mut val as *mut _);
-    //~^ ref_as_ptr
 
     f(&mut val as *const u8);
-    //~^ ref_as_ptr
     f(&mut val as *const _);
-    //~^ ref_as_ptr
 
     f(&mut val as *const u8 as *const f64);
-    //~^ ref_as_ptr
     f::<*const Option<u8>>(&mut val as *const _ as *const _);
-    //~^ ref_as_ptr
 
     f(&std::array::from_fn(|i| i * i) as *const [usize; 7]);
     //~^ ref_as_ptr
@@ -87,8 +77,9 @@ fn main() {
     //~^ ref_as_ptr
 
     let _ = &String::new() as *const _;
+    //~^ ref_as_ptr
     let _ = &mut String::new() as *mut _;
-    const FOO: *const String = &String::new() as *const _;
+    //~^ ref_as_ptr
 }
 
 #[clippy::msrv = "1.75"]
@@ -107,36 +98,28 @@ fn _msrv_1_76() {
     let mut_val = &mut 42_i32;
 
     f(val as *const i32);
-    //~^ ref_as_ptr
     f(mut_val as *mut i32);
-    //~^ ref_as_ptr
 }
 
 fn foo(val: &[u8]) {
     f(val as *const _);
-    //~^ ref_as_ptr
     f(val as *const [u8]);
-    //~^ ref_as_ptr
 }
 
 fn bar(val: &mut str) {
     f(val as *mut _);
-    //~^ ref_as_ptr
     f(val as *mut str);
-    //~^ ref_as_ptr
 }
 
 struct X<'a>(&'a i32);
 
 impl<'a> X<'a> {
     fn foo(&self) -> *const i64 {
         self.0 as *const _ as *const _
-        //~^ ref_as_ptr
     }
 
     fn bar(&mut self) -> *const i64 {
         self.0 as *const _ as *const _
-        //~^ ref_as_ptr
     }
 }
 
@@ -145,16 +128,13 @@ struct Y<'a>(&'a mut i32);
 impl<'a> Y<'a> {
     fn foo(&self) -> *const i64 {
         self.0 as *const _ as *const _
-        //~^ ref_as_ptr
     }
 
     fn bar(&mut self) -> *const i64 {
         self.0 as *const _ as *const _
-        //~^ ref_as_ptr
     }
 
     fn baz(&mut self) -> *const i64 {
         self.0 as *mut _ as *mut _
-        //~^ ref_as_ptr
     }
 }