uplift clippy::clone_double_ref to rustc

Author: fee1-dead

compiler/rustc_lint/messages.ftl

@@ -5,6 +5,13 @@ lint_array_into_iter =
     .use_explicit_into_iter_suggestion =
         or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
 
+lint_clone_double_ref =
+    using `clone` on a double-reference, which copies the reference of type `{$ty}` instead of cloning the inner type
+
+lint_clone_double_ref_try_deref = try dereferencing it
+
+lint_clone_double_ref_sugg_explicit = or try being explicit if you are sure, that you want to clone a reference
+
 lint_enum_intrinsics_mem_discriminant =
     the return value of `mem::discriminant` is unspecified when called with a non-enum type
     .note = the argument to `discriminant` should be a reference to an enum, but it was passed a reference to a `{$ty_param}`, which is not an enum.

compiler/rustc_lint/src/clone_double_ref.rs

@@ -0,0 +1,86 @@
+use crate::lints::{CloneDoubleRefExplicit, CloneDoubleRefTryDeref};
+use crate::{lints, LateLintPass, LintContext};
+
+use rustc_hir as hir;
+use rustc_hir::ExprKind;
+use rustc_middle::ty;
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_span::sym;
+
+declare_lint! {
+    /// The `clone_double_ref` lint checks for usage of `.clone()` on an `&&T`,
+    /// which copies the inner `&T`, instead of cloning the underlying `T` and
+    /// can be confusing.
+    pub CLONE_DOUBLE_REF,
+    Warn,
+    "using `clone` on `&&T`"
+}
+
+declare_lint_pass!(CloneDoubleRef => [CLONE_DOUBLE_REF]);
+
+impl<'tcx> LateLintPass<'tcx> for CloneDoubleRef {
+    fn check_expr(&mut self, cx: &crate::LateContext<'tcx>, e: &'tcx hir::Expr<'tcx>) {
+        let ExprKind::MethodCall(path, receiver, args, _) = &e.kind else { return; };
+
+        if path.ident.name != sym::clone || !args.is_empty() {
+            return;
+        }
+
+        let typeck_results = cx.typeck_results();
+
+        if typeck_results
+            .type_dependent_def_id(e.hir_id)
+            .and_then(|id| cx.tcx.trait_of_item(id))
+            .zip(cx.tcx.lang_items().clone_trait())
+            .map_or(true, |(x, y)| x != y)
+        {
+            return;
+        }
+
+        let arg_adjustments = cx.typeck_results().expr_adjustments(receiver);
+
+        // https://github.com/rust-lang/rust-clippy/issues/9272
+        if arg_adjustments.iter().any(|adj| matches!(adj.kind, Adjust::Deref(Some(_)))) {
+            return;
+        }
+
+        if !receiver.span.eq_ctxt(e.span) {
+            return;
+        }
+
+        let arg_ty = arg_adjustments
+            .last()
+            .map_or_else(|| cx.typeck_results().expr_ty(receiver), |a| a.target);
+
+        let ty = cx.typeck_results().expr_ty(e);
+
+        if let ty::Ref(_, inner, _) = arg_ty.kind()
+            && let ty::Ref(_, innermost, _) = inner.kind() {
+                let mut inner_ty = innermost;
+                let mut n = 1;
+                while let ty::Ref(_, inner, _) = inner_ty.kind() {
+                    inner_ty = inner;
+                    n += 1;
+                }
+                let refs = "&".repeat(n);
+                let derefs = "*".repeat(n);
+                let start = e.span.with_hi(receiver.span.lo());
+                let end = e.span.with_lo(receiver.span.hi());
+                cx.emit_spanned_lint(CLONE_DOUBLE_REF, e.span, lints::CloneDoubleRef {
+                    ty,
+                    try_deref: CloneDoubleRefTryDeref {
+                        start,
+                        end,
+                        refs: refs.clone(),
+                        derefs,
+                    },
+                    explicit: CloneDoubleRefExplicit {
+                        start,
+                        end,
+                        refs,
+                        ty: *inner_ty,
+                    }
+                });
+        }
+    }
+}

compiler/rustc_lint/src/lib.rs

@@ -50,6 +50,7 @@ extern crate tracing;
 
 mod array_into_iter;
 pub mod builtin;
+mod clone_double_ref;
 mod context;
 mod deref_into_dyn_supertrait;
 mod early;
@@ -95,6 +96,7 @@ use rustc_span::Span;
 
 use array_into_iter::ArrayIntoIter;
 use builtin::*;
+use clone_double_ref::CloneDoubleRef;
 use deref_into_dyn_supertrait::*;
 use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
 use for_loops_over_fallibles::*;
@@ -199,6 +201,7 @@ late_lint_methods!(
     [
         BuiltinCombinedModuleLateLintPass,
         [
+            CloneDoubleRef: CloneDoubleRef,
             ForLoopsOverFallibles: ForLoopsOverFallibles,
             DerefIntoDynSupertrait: DerefIntoDynSupertrait,
             HardwiredLints: HardwiredLints,

compiler/rustc_lint/src/lints.rs

@@ -564,6 +564,38 @@ pub struct BuiltinUnexpectedCliConfigValue {
     pub value: Symbol,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_clone_double_ref)]
+pub struct CloneDoubleRef<'a> {
+    pub ty: Ty<'a>,
+    #[subdiagnostic]
+    pub try_deref: CloneDoubleRefTryDeref,
+    #[subdiagnostic]
+    pub explicit: CloneDoubleRefExplicit<'a>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(lint_clone_double_ref_sugg_explicit, applicability = "maybe-incorrect")]
+pub struct CloneDoubleRefExplicit<'a> {
+    #[suggestion_part(code = "<{refs}{ty}>::clone(")]
+    pub start: Span,
+    #[suggestion_part(code = ")")]
+    pub end: Span,
+    pub refs: String,
+    pub ty: Ty<'a>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(lint_clone_double_ref_try_deref, applicability = "maybe-incorrect")]
+pub struct CloneDoubleRefTryDeref {
+    #[suggestion_part(code = "{refs}({derefs}")]
+    pub start: Span,
+    #[suggestion_part(code = ").clone()")]
+    pub end: Span,
+    pub refs: String,
+    pub derefs: String,
+}
+
 // deref_into_dyn_supertrait.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_supertrait_as_deref_target)]

tests/ui/lint/clone-double-ref.rs

@@ -0,0 +1,23 @@
+#![feature(once_cell)]
+#![deny(clone_double_ref)]
+
+pub fn clone_on_double_ref() {
+    let x = vec![1];
+    let y = &&x;
+    let z: &Vec<_> = y.clone();
+    //~^ ERROR using `clone` on a double-reference, which copies the reference of type `Vec<i32>`
+
+    println!("{:p} {:p}", *y, z);
+}
+
+use std::sync::LazyLock;
+
+pub static STRS: LazyLock<&str> = LazyLock::new(|| "First");
+
+// https://github.com/rust-lang/rust-clippy/issues/9272
+fn rust_clippy_issue_9272() {
+    let str = STRS.clone();
+    println!("{str}")
+}
+
+fn main() {}

tests/ui/lint/clone-double-ref.stderr

@@ -0,0 +1,22 @@
+error: using `clone` on a double-reference, which copies the reference of type `Vec<i32>` instead of cloning the inner type
+  --> $DIR/clone-double-ref.rs:7:22
+   |
+LL |     let z: &Vec<_> = y.clone();
+   |                      ^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/clone-double-ref.rs:2:9
+   |
+LL | #![deny(clone_double_ref)]
+   |         ^^^^^^^^^^^^^^^^
+help: try dereferencing it
+   |
+LL |     let z: &Vec<_> = &(*y).clone();
+   |                      +++ ~~~~~~~~~
+help: or try being explicit if you are sure, that you want to clone a reference
+   |
+LL |     let z: &Vec<_> = <&Vec<i32>>::clone(y);
+   |                      +++++++++++++++++++ ~
+
+error: aborting due to previous error
+