rename to suspicious_double_ref_op and fix CI

Author: fee1-dead

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -573,7 +573,7 @@ fn link_dwarf_object<'a>(
 
     impl<Relocations> ThorinSession<Relocations> {
         fn alloc_mmap(&self, data: Mmap) -> &Mmap {
-            (*self.arena_mmap.alloc(data)).borrow()
+            &*self.arena_mmap.alloc(data)
         }
     }
 
@@ -583,7 +583,7 @@ fn link_dwarf_object<'a>(
         }
 
         fn alloc_relocation(&self, data: Relocations) -> &Relocations {
-            (*self.arena_relocations.alloc(data)).borrow()
+            &*self.arena_relocations.alloc(data)
         }
 
         fn read_input(&self, path: &Path) -> std::io::Result<&[u8]> {

compiler/rustc_lint/messages.ftl

@@ -5,7 +5,7 @@ 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 =
+lint_suspicious_double_ref_op =
     using `.{$call}()` on a double reference, which copies `{$ty}` instead of {$op} the inner type
 
 lint_enum_intrinsics_mem_discriminant =

compiler/rustc_lint/src/lints.rs

@@ -565,7 +565,7 @@ pub struct BuiltinUnexpectedCliConfigValue {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(lint_clone_double_ref)]
+#[diag(lint_suspicious_double_ref_op)]
 pub struct CloneDoubleRef<'a> {
     pub call: Symbol,
     pub ty: Ty<'a>,

compiler/rustc_lint/src/noop_method_call.rs

@@ -37,15 +37,15 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `clone_double_ref` lint checks for usage of `.clone()` on an `&&T`,
+    /// The `suspicious_double_ref_op` 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,
+    pub SUSPICIOUS_DOUBLE_REF_OP,
     Warn,
     "using `clone` on `&&T`"
 }
 
-declare_lint_pass!(NoopMethodCall => [NOOP_METHOD_CALL, CLONE_DOUBLE_REF]);
+declare_lint_pass!(NoopMethodCall => [NOOP_METHOD_CALL, SUSPICIOUS_DOUBLE_REF_OP]);
 
 impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -115,7 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
             );
         } else {
             cx.emit_spanned_lint(
-                CLONE_DOUBLE_REF,
+                SUSPICIOUS_DOUBLE_REF_OP,
                 span,
                 CloneDoubleRef { call: call.ident.name, ty: expr_ty, op },
             )

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -39,7 +39,6 @@ use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::{BytePos, DesugaringKind, ExpnKind, MacroKind, Span, DUMMY_SP};
 use rustc_target::spec::abi;
-use std::ops::Deref;
 
 use super::method_chain::CollectAllMismatches;
 use super::InferCtxtPrivExt;
@@ -3571,7 +3570,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
             // trait_pred `S: Sum<<Self as Iterator>::Item>` and predicate `i32: Sum<&()>`
             let mut type_diffs = vec![];
 
-            if let ObligationCauseCode::ExprBindingObligation(def_id, _, _, idx) = parent_code.deref()
+            if let ObligationCauseCode::ExprBindingObligation(def_id, _, _, idx) = parent_code
                 && let Some(node_substs) = typeck_results.node_substs_opt(call_hir_id)
                 && let where_clauses = self.tcx.predicates_of(def_id).instantiate(self.tcx, node_substs)
                 && let Some(where_pred) = where_clauses.predicates.get(*idx)

library/core/benches/iter.rs

@@ -1,4 +1,3 @@
-use core::borrow::Borrow;
 use core::iter::*;
 use core::mem;
 use core::num::Wrapping;
@@ -428,7 +427,7 @@ fn bench_trusted_random_access_chunks(b: &mut Bencher) {
         black_box(&v)
             .iter()
             // this shows that we're not relying on the slice::Iter specialization in Copied
-            .map(|b| *b.borrow())
+            .map(|b| *b)
             .array_chunks::<{ mem::size_of::<u64>() }>()
             .map(|ary| {
                 let d = u64::from_ne_bytes(ary);

library/core/tests/clone.rs

@@ -1,4 +1,5 @@
 #[test]
+#[cfg_attr(not(bootstrap), allow(suspicious_double_ref_op))]
 fn test_borrowed_clone() {
     let x = 5;
     let y: &i32 = &x;

src/tools/clippy/clippy_lints/src/renamed_lints.rs

@@ -30,7 +30,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::stutter", "clippy::module_name_repetitions"),
     ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
     ("clippy::zero_width_space", "clippy::invisible_characters"),
-    ("clippy::clone_double_ref", "clone_double_ref"),
+    ("clippy::clone_double_ref", "suspicious_double_ref_op"),
     ("clippy::drop_bounds", "drop_bounds"),
     ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
     ("clippy::for_loop_over_result", "for_loops_over_fallibles"),

src/tools/clippy/tests/ui/explicit_deref_methods.fixed

@@ -2,8 +2,8 @@
 #![warn(clippy::explicit_deref_methods)]
 #![allow(unused_variables)]
 #![allow(
+    noop_method_call,
     clippy::borrow_deref_ref,
-    clone_double_ref,
     clippy::explicit_auto_deref,
     clippy::needless_borrow,
     clippy::uninlined_format_args

src/tools/clippy/tests/ui/explicit_deref_methods.rs

@@ -2,8 +2,8 @@
 #![warn(clippy::explicit_deref_methods)]
 #![allow(unused_variables)]
 #![allow(
+    noop_method_call,
     clippy::borrow_deref_ref,
-    clone_double_ref,
     clippy::explicit_auto_deref,
     clippy::needless_borrow,
     clippy::uninlined_format_args

src/tools/clippy/tests/ui/rename.fixed

@@ -27,7 +27,6 @@
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::recursive_format_impl)]
 #![allow(clippy::invisible_characters)]
-#![allow(clone_double_ref)]
 #![allow(drop_bounds)]
 #![allow(for_loops_over_fallibles)]
 #![allow(array_into_iter)]
@@ -37,6 +36,7 @@
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
 #![allow(named_arguments_used_positionally)]
+#![allow(suspicious_double_ref_op)]
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
@@ -68,7 +68,7 @@
 #![warn(clippy::module_name_repetitions)]
 #![warn(clippy::recursive_format_impl)]
 #![warn(clippy::invisible_characters)]
-#![warn(clone_double_ref)]
+#![warn(suspicious_double_ref_op)]
 #![warn(drop_bounds)]
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]

src/tools/clippy/tests/ui/rename.rs

@@ -27,7 +27,6 @@
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::recursive_format_impl)]
 #![allow(clippy::invisible_characters)]
-#![allow(clone_double_ref)]
 #![allow(drop_bounds)]
 #![allow(for_loops_over_fallibles)]
 #![allow(array_into_iter)]
@@ -37,6 +36,7 @@
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
 #![allow(named_arguments_used_positionally)]
+#![allow(suspicious_double_ref_op)]
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]

src/tools/clippy/tests/ui/rename.stderr

@@ -168,11 +168,11 @@ error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_ch
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
-error: lint `clippy::clone_double_ref` has been renamed to `clone_double_ref`
+error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
   --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::clone_double_ref)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clone_double_ref`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
   --> $DIR/rename.rs:72:9

src/tools/compiletest/src/main.rs

@@ -1114,7 +1114,7 @@ fn check_overlapping_tests(found_paths: &BTreeSet<PathBuf>) {
     for path in found_paths {
         for ancestor in path.ancestors().skip(1) {
             if found_paths.contains(ancestor) {
-                collisions.push((path, ancestor.clone()));
+                collisions.push((path, ancestor));
             }
         }
     }

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

@@ -1,5 +1,5 @@
 #![feature(lazy_cell)]
-#![deny(clone_double_ref, noop_method_call)]
+#![deny(suspicious_double_ref_op, noop_method_call)]
 
 pub fn clone_on_double_ref() {
     let x = vec![1];

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

@@ -7,8 +7,8 @@ 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, noop_method_call)]
-   |         ^^^^^^^^^^^^^^^^
+LL | #![deny(suspicious_double_ref_op, noop_method_call)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: call to `.clone()` on a reference in this situation does nothing
   --> $DIR/clone-double-ref.rs:24:25
@@ -18,10 +18,10 @@ LL |     let _ = &mut encoded.clone();
    |
    = note: the type `&[u8]` which `clone` is being called on is the same as the type returned from `clone`, so the method call does not do anything and can be removed
 note: the lint level is defined here
-  --> $DIR/clone-double-ref.rs:2:27
+  --> $DIR/clone-double-ref.rs:2:35
    |
-LL | #![deny(clone_double_ref, noop_method_call)]
-   |                           ^^^^^^^^^^^^^^^^
+LL | #![deny(suspicious_double_ref_op, noop_method_call)]
+   |                                   ^^^^^^^^^^^^^^^^
 
 error: call to `.clone()` on a reference in this situation does nothing
   --> $DIR/clone-double-ref.rs:26:21

tests/ui/lint/noop-method-call.rs

@@ -1,7 +1,7 @@
 // check-pass
 
 #![allow(unused)]
-#![warn(noop_method_call, clone_double_ref)]
+#![warn(noop_method_call, suspicious_double_ref_op)]
 
 use std::borrow::Borrow;
 use std::ops::Deref;

tests/ui/lint/noop-method-call.stderr

@@ -8,7 +8,7 @@ LL |     let non_clone_type_ref_clone: &PlainType<u32> = non_clone_type_ref.clon
 note: the lint level is defined here
   --> $DIR/noop-method-call.rs:4:9
    |
-LL | #![warn(noop_method_call, clone_double_ref)]
+LL | #![warn(noop_method_call, suspicious_double_ref_op)]
    |         ^^^^^^^^^^^^^^^^
 
 warning: using `.clone()` on a double reference, which copies `&CloneType<u32>` instead of cloning the inner type
@@ -20,8 +20,8 @@ LL |     let clone_type_ref_clone: &CloneType<u32> = clone_type_ref.clone();
 note: the lint level is defined here
   --> $DIR/noop-method-call.rs:4:27
    |
-LL | #![warn(noop_method_call, clone_double_ref)]
-   |                           ^^^^^^^^^^^^^^^^
+LL | #![warn(noop_method_call, suspicious_double_ref_op)]
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: call to `.deref()` on a reference in this situation does nothing
   --> $DIR/noop-method-call.rs:27:63

tests/ui/trait-bounds/issue-94680.rs

@@ -1,6 +1,6 @@
 // check-pass
 
-#![allow(clone_double_ref)]
+#![allow(suspicious_double_ref_op)]
 
 fn main() {
     println!("{:?}", {

tests/ui/trivial-bounds/issue-73021-impossible-inline.rs

@@ -2,7 +2,7 @@
 // revisions: no-opt inline
 // [inline]compile-flags: -Zmir-opt-level=3 --emit=mir
 #![feature(trivial_bounds)]
-#![allow(unused, clone_double_ref)]
+#![allow(unused, suspicious_double_ref_op)]
 
 trait Foo {
     fn test(&self);