Drop uplifted clippy::drop_ref

Author: Urgau

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

@@ -133,7 +133,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     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::DROP_REF_INFO,
     crate::drop_forget_ref::FORGET_COPY_INFO,
     crate::drop_forget_ref::FORGET_NON_DROP_INFO,
     crate::drop_forget_ref::FORGET_REF_INFO,

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

@@ -7,30 +7,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `std::mem::drop` with a reference
-    /// instead of an owned value.
-    ///
-    /// ### Why is this bad?
-    /// Calling `drop` on a reference will only drop the
-    /// reference itself, which is a no-op. It will not call the `drop` method (from
-    /// the `Drop` trait implementation) on the underlying referenced value, which
-    /// is likely what was intended.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let mut lock_guard = mutex.lock();
-    /// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex
-    /// // still locked
-    /// operation_that_requires_mutex_to_be_unlocked();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DROP_REF,
-    correctness,
-    "calls to `std::mem::drop` with a reference instead of an owned value"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `std::mem::forget` with a reference
@@ -172,8 +148,6 @@ declare_clippy_lint! {
     "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
 }
 
-const DROP_REF_SUMMARY: &str = "calls to `std::mem::drop` with a reference instead of an owned value. \
-                                Dropping a reference does nothing";
 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`. \
@@ -186,7 +160,6 @@ const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value t
                                    Forgetting such a type is the same as dropping it";
 
 declare_lint_pass!(DropForgetRef => [
-    DROP_REF,
     FORGET_REF,
     DROP_COPY,
     FORGET_COPY,
@@ -206,7 +179,8 @@ 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 {
-                sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => (DROP_REF, DROP_REF_SUMMARY),
+                // early return for uplifted lints: drop_ref
+                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_forget if is_copy => (FORGET_COPY, FORGET_COPY_SUMMARY),

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_ref", "drop_ref"),
     ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
     ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
     ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),

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

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

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

@@ -23,6 +23,18 @@ 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
+  --> $DIR/drop_forget_copy.rs:35:5
+   |
+LL |     drop(s3);
+   |     ^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_forget_copy.rs:35:10
+   |
+LL |     drop(s3);
+   |          ^^
+
 error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:36:5
    |
@@ -35,6 +47,18 @@ 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
+  --> $DIR/drop_forget_copy.rs:37:5
+   |
+LL |     drop(s5);
+   |     ^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_forget_copy.rs:37:10
+   |
+LL |     drop(s5);
+   |          ^^
+
 error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:39:5
    |
@@ -72,6 +96,30 @@ 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
+  --> $DIR/drop_forget_copy.rs:55:5
+   |
+LL |     drop(a2);
+   |     ^^^^^^^^
+   |
+note: argument has type `&AnotherStruct`
+  --> $DIR/drop_forget_copy.rs:55:10
+   |
+LL |     drop(a2);
+   |          ^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:57:5
+   |
+LL |     drop(a4);
+   |     ^^^^^^^^
+   |
+note: argument has type `&AnotherStruct`
+  --> $DIR/drop_forget_copy.rs:57:10
+   |
+LL |     drop(a4);
+   |          ^^
+
 error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:80:13
    |
@@ -108,5 +156,5 @@ note: argument has type `i32`
 LL |         4 => drop(2),                           // Lint, not a fn/method call
    |                   ^
 
-error: aborting due to 9 previous errors
+error: aborting due to 13 previous errors