Drop uplifted clippy::drop_copy

Author: Urgau

src/tools/clippy/clippy_lints/src/declared_lints.rs

@@ -131,7 +131,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::doc::NEEDLESS_DOCTEST_MAIN_INFO,
     crate::doc::UNNECESSARY_SAFETY_DOC_INFO,
     crate::double_parens::DOUBLE_PARENS_INFO,
-    crate::drop_forget_ref::DROP_COPY_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
     crate::drop_forget_ref::FORGET_COPY_INFO,
     crate::drop_forget_ref::FORGET_NON_DROP_INFO,

src/tools/clippy/clippy_lints/src/drop_forget_ref.rs

@@ -29,28 +29,6 @@ declare_clippy_lint! {
     "calls to `std::mem::forget` with a reference instead of an owned value"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `std::mem::drop` with a value
-    /// that derives the Copy trait
-    ///
-    /// ### Why is this bad?
-    /// Calling `std::mem::drop` [does nothing for types that
-    /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the
-    /// value will be copied and moved into the function on invocation.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x: i32 = 42; // i32 implements Copy
-    /// std::mem::drop(x) // A copy of x is passed to the function, leaving the
-    ///                   // original unaffected
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DROP_COPY,
-    correctness,
-    "calls to `std::mem::drop` with a value that implements Copy"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `std::mem::forget` with a value that
@@ -150,8 +128,6 @@ declare_clippy_lint! {
 
 const FORGET_REF_SUMMARY: &str = "calls to `std::mem::forget` with a reference instead of an owned value. \
                                   Forgetting a reference does nothing";
-const DROP_COPY_SUMMARY: &str = "calls to `std::mem::drop` with a value that implements `Copy`. \
-                                 Dropping a copy leaves the original intact";
 const FORGET_COPY_SUMMARY: &str = "calls to `std::mem::forget` with a value that implements `Copy`. \
                                    Forgetting a copy leaves the original intact";
 const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
@@ -161,7 +137,6 @@ const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value t
 
 declare_lint_pass!(DropForgetRef => [
     FORGET_REF,
-    DROP_COPY,
     FORGET_COPY,
     DROP_NON_DROP,
     FORGET_NON_DROP,
@@ -179,10 +154,10 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
             let is_copy = is_copy(cx, arg_ty);
             let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr);
             let (lint, msg) = match fn_name {
-                // early return for uplifted lints: drop_ref
+                // early return for uplifted lints: drop_ref, drop_copy
                 sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => return,
                 sym::mem_forget if arg_ty.is_ref() => (FORGET_REF, FORGET_REF_SUMMARY),
-                sym::mem_drop if is_copy && !drop_is_single_call_in_arm => (DROP_COPY, DROP_COPY_SUMMARY),
+                sym::mem_drop if is_copy && !drop_is_single_call_in_arm => return,
                 sym::mem_forget if is_copy => (FORGET_COPY, FORGET_COPY_SUMMARY),
                 sym::mem_drop if is_type_lang_item(cx, arg_ty, LangItem::ManuallyDrop) => {
                     span_lint_and_help(

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

@@ -31,6 +31,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
     ("clippy::zero_width_space", "clippy::invisible_characters"),
     ("clippy::drop_bounds", "drop_bounds"),
+    ("clippy::drop_copy", "drop_copy"),
     ("clippy::drop_ref", "drop_ref"),
     ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
     ("clippy::for_loop_over_result", "for_loops_over_fallibles"),

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

@@ -1,4 +1,4 @@
-#![warn(clippy::drop_copy, clippy::forget_copy)]
+#![warn(drop_copy, clippy::forget_copy)]
 #![allow(clippy::toplevel_ref_arg, drop_ref, clippy::forget_ref, unused_mut)]
 
 use std::mem::{drop, forget};

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

@@ -1,4 +1,4 @@
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:33:5
    |
 LL |     drop(s1);
@@ -9,9 +9,9 @@ note: argument has type `SomeStruct`
    |
 LL |     drop(s1);
    |          ^^
-   = note: `-D clippy::drop-copy` implied by `-D warnings`
+   = note: `-D clippy::drop-non-drop` implied by `-D warnings`
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:34:5
    |
 LL |     drop(s2);
@@ -23,7 +23,7 @@ note: argument has type `SomeStruct`
 LL |     drop(s2);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:35:5
    |
 LL |     drop(s3);
@@ -35,7 +35,7 @@ note: argument has type `&SomeStruct`
 LL |     drop(s3);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:36:5
    |
 LL |     drop(s4);
@@ -47,7 +47,7 @@ note: argument has type `SomeStruct`
 LL |     drop(s4);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:37:5
    |
 LL |     drop(s5);
@@ -96,7 +96,7 @@ note: argument has type `SomeStruct`
 LL |     forget(s4);
    |            ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:55:5
    |
 LL |     drop(a2);
@@ -108,7 +108,7 @@ note: argument has type `&AnotherStruct`
 LL |     drop(a2);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:57:5
    |
 LL |     drop(a4);
@@ -120,7 +120,7 @@ note: argument has type `&AnotherStruct`
 LL |     drop(a4);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:80:13
    |
 LL |             drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
@@ -132,7 +132,7 @@ note: argument has type `i32`
 LL |             drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
    |                  ^^^^^^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:82:14
    |
 LL |         3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
@@ -144,7 +144,7 @@ note: argument has type `i32`
 LL |         3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
    |                   ^^^^^^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_forget_copy.rs:83:14
    |
 LL |         4 => drop(2),                           // Lint, not a fn/method call
@@ -156,5 +156,78 @@ note: argument has type `i32`
 LL |         4 => drop(2),                           // Lint, not a fn/method call
    |                   ^
 
-error: aborting due to 13 previous errors
+error: calls to `std::mem::drop` with a value that implements `Copy`.
+  --> $DIR/drop_forget_copy.rs:33:5
+   |
+LL |     drop(s1);
+   |     ^^^^^^^^
+   |
+note: argument has type `SomeStruct`
+  --> $DIR/drop_forget_copy.rs:33:10
+   |
+LL |     drop(s1);
+   |          ^^
+   = note: `-D drop-copy` implied by `-D warnings`
+
+error: calls to `std::mem::drop` with a value that implements `Copy`.
+  --> $DIR/drop_forget_copy.rs:34:5
+   |
+LL |     drop(s2);
+   |     ^^^^^^^^
+   |
+note: argument has type `SomeStruct`
+  --> $DIR/drop_forget_copy.rs:34:10
+   |
+LL |     drop(s2);
+   |          ^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`.
+  --> $DIR/drop_forget_copy.rs:36:5
+   |
+LL |     drop(s4);
+   |     ^^^^^^^^
+   |
+note: argument has type `SomeStruct`
+  --> $DIR/drop_forget_copy.rs:36:10
+   |
+LL |     drop(s4);
+   |          ^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`.
+  --> $DIR/drop_forget_copy.rs:80:13
+   |
+LL |             drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `i32`
+  --> $DIR/drop_forget_copy.rs:80:18
+   |
+LL |             drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
+   |                  ^^^^^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`.
+  --> $DIR/drop_forget_copy.rs:82:14
+   |
+LL |         3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `i32`
+  --> $DIR/drop_forget_copy.rs:82:19
+   |
+LL |         3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+   |                   ^^^^^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`.
+  --> $DIR/drop_forget_copy.rs:83:14
+   |
+LL |         4 => drop(2),                           // Lint, not a fn/method call
+   |              ^^^^^^^
+   |
+note: argument has type `i32`
+  --> $DIR/drop_forget_copy.rs:83:19
+   |
+LL |         4 => drop(2),                           // Lint, not a fn/method call
+   |                   ^
+
+error: aborting due to 19 previous errors
 

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

@@ -2,7 +2,7 @@
 #![allow(unused)]
 #![allow(deref_nullptr)]
 #![allow(clippy::unnecessary_operation)]
-#![allow(clippy::drop_copy)]
+#![allow(drop_copy)]
 #![warn(clippy::multiple_unsafe_ops_per_block)]
 
 extern crate proc_macros;

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

@@ -28,6 +28,7 @@
 #![allow(clippy::recursive_format_impl)]
 #![allow(clippy::invisible_characters)]
 #![allow(drop_bounds)]
+#![allow(drop_copy)]
 #![allow(drop_ref)]
 #![allow(for_loops_over_fallibles)]
 #![allow(array_into_iter)]
@@ -69,6 +70,7 @@
 #![warn(clippy::recursive_format_impl)]
 #![warn(clippy::invisible_characters)]
 #![warn(drop_bounds)]
+#![warn(drop_copy)]
 #![warn(drop_ref)]
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]

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

@@ -28,6 +28,7 @@
 #![allow(clippy::recursive_format_impl)]
 #![allow(clippy::invisible_characters)]
 #![allow(drop_bounds)]
+#![allow(drop_copy)]
 #![allow(drop_ref)]
 #![allow(for_loops_over_fallibles)]
 #![allow(array_into_iter)]
@@ -69,6 +70,7 @@
 #![warn(clippy::to_string_in_display)]
 #![warn(clippy::zero_width_space)]
 #![warn(clippy::drop_bounds)]
+#![warn(clippy::drop_copy)]
 #![warn(clippy::drop_ref)]
 #![warn(clippy::for_loop_over_option)]
 #![warn(clippy::for_loop_over_result)]