Make borrow_as_ptr flag implicit casts as well

Author: samueltardieu

clippy_lints/src/casts/borrow_as_ptr.rs

@@ -1,11 +1,12 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::{is_expr_temporary_value, is_lint_allowed, msrvs, std_or_core};
+use clippy_utils::{get_parent_expr, is_expr_temporary_value, is_lint_allowed, msrvs, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::{Adjust, AutoBorrow};
 use rustc_span::BytePos;
 
 use super::BORROW_AS_PTR;
@@ -59,3 +60,32 @@ pub(super) fn check<'tcx>(
     }
     false
 }
+
+pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if !expr.span.from_expansion()
+        && !matches!(get_parent_expr(cx, expr).map(|e| e.kind), Some(ExprKind::Cast(..)))
+        && let [deref, borrow] = cx.typeck_results().expr_adjustments(expr)
+        && matches!(deref.kind, Adjust::Deref(..))
+        && cx.typeck_results().expr_ty(expr).is_ref()
+        && let Adjust::Borrow(AutoBorrow::RawPtr(mutability)) = borrow.kind
+    {
+        let mode = if mutability == Mutability::Not { "const" } else { "mut" };
+        span_lint_and_then(cx, BORROW_AS_PTR, expr.span, "implicit borrow as raw pointer", |diag| {
+            let (msg, suggs) = if let ExprKind::AddrOf(BorrowKind::Ref, _, target) = expr.kind {
+                (
+                    "use a raw pointer instead",
+                    vec![
+                        (expr.span.shrink_to_lo(), format!("&raw {mode} ")),
+                        (expr.span.until(target.span), String::new()),
+                    ],
+                )
+            } else {
+                (
+                    "reborrow as a raw pointer",
+                    vec![(expr.span.shrink_to_lo(), format!("&raw {mode} *"))],
+                )
+            };
+            diag.multipart_suggestion_verbose(msg, suggs, Applicability::MachineApplicable);
+        });
+    }
+}

clippy_lints/src/casts/mod.rs

@@ -846,6 +846,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             }
         }
 
+        if self.msrv.meets(cx, msrvs::BORROW_AS_PTR) {
+            borrow_as_ptr::check_implicit_cast(cx, expr);
+        }
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
         ptr_as_ptr::check(cx, expr, self.msrv);

clippy_lints/src/non_copy_const.rs

@@ -449,7 +449,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst<'tcx> {
 
                             dereferenced_expr = parent_expr;
                         },
-                        ExprKind::Index(e, _, _) if ptr::eq(&**e, cur_expr) => {
+                        ExprKind::Index(e, _, _) if ptr::eq(&raw const **e, &raw const *cur_expr) => {
                             // `e[i]` => desugared to `*Index::index(&e, i)`,
                             // meaning `e` must be referenced.
                             // no need to go further up since a method call is involved now.

tests/ui/borrow_as_ptr.fixed

@@ -29,3 +29,19 @@ fn issue_13882() {
     let _raw = (&raw mut x[1]).wrapping_offset(-1);
     //~^ borrow_as_ptr
 }
+
+fn implicit_cast() {
+    let val = 1;
+    let p: *const i32 = &raw const val;
+    //~^ borrow_as_ptr
+
+    let mut val = 1;
+    let p: *mut i32 = &raw mut val;
+    //~^ borrow_as_ptr
+
+    let mut r = &mut 1;
+    let p: *const i32 = &raw const *r;
+    //~^ borrow_as_ptr
+    let p: *mut i32 = &raw mut *r;
+    //~^ borrow_as_ptr
+}

tests/ui/borrow_as_ptr.rs

@@ -29,3 +29,19 @@ fn issue_13882() {
     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
     //~^ borrow_as_ptr
 }
+
+fn implicit_cast() {
+    let val = 1;
+    let p: *const i32 = &val;
+    //~^ borrow_as_ptr
+
+    let mut val = 1;
+    let p: *mut i32 = &mut val;
+    //~^ borrow_as_ptr
+
+    let mut r = &mut 1;
+    let p: *const i32 = r;
+    //~^ borrow_as_ptr
+    let p: *mut i32 = r;
+    //~^ borrow_as_ptr
+}

tests/ui/borrow_as_ptr.stderr

@@ -25,5 +25,51 @@ error: borrow as raw pointer
 LL |     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: try: `&raw mut x[1]`
 
-error: aborting due to 4 previous errors
+error: implicit borrow as raw pointer
+  --> tests/ui/borrow_as_ptr.rs:35:25
+   |
+LL |     let p: *const i32 = &val;
+   |                         ^^^^
+   |
+help: use a raw pointer instead
+   |
+LL -     let p: *const i32 = &val;
+LL +     let p: *const i32 = &raw const val;
+   |
+
+error: implicit borrow as raw pointer
+  --> tests/ui/borrow_as_ptr.rs:39:23
+   |
+LL |     let p: *mut i32 = &mut val;
+   |                       ^^^^^^^^
+   |
+help: use a raw pointer instead
+   |
+LL -     let p: *mut i32 = &mut val;
+LL +     let p: *mut i32 = &raw mut val;
+   |
+
+error: implicit borrow as raw pointer
+  --> tests/ui/borrow_as_ptr.rs:43:25
+   |
+LL |     let p: *const i32 = r;
+   |                         ^
+   |
+help: reborrow as a raw pointer
+   |
+LL |     let p: *const i32 = &raw const *r;
+   |                         ++++++++++++
+
+error: implicit borrow as raw pointer
+  --> tests/ui/borrow_as_ptr.rs:45:23
+   |
+LL |     let p: *mut i32 = r;
+   |                       ^
+   |
+help: reborrow as a raw pointer
+   |
+LL |     let p: *mut i32 = &raw mut *r;
+   |                       ++++++++++
+
+error: aborting due to 8 previous errors