Drop uplifted clippy::forget_copy

Author: Urgau

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

@@ -133,7 +133,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::doc::UNNECESSARY_SAFETY_DOC_INFO,
     crate::double_parens::DOUBLE_PARENS_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
-    crate::drop_forget_ref::FORGET_COPY_INFO,
     crate::drop_forget_ref::FORGET_NON_DROP_INFO,
     crate::drop_forget_ref::UNDROPPED_MANUALLY_DROPS_INFO,
     crate::duplicate_mod::DUPLICATE_MOD_INFO,

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

@@ -7,34 +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::forget` with a value that
-    /// derives the Copy trait
-    ///
-    /// ### Why is this bad?
-    /// Calling `std::mem::forget` [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.
-    ///
-    /// An alternative, but also valid, explanation is that Copy types do not
-    /// implement
-    /// the Drop trait, which means they have no destructors. Without a destructor,
-    /// there
-    /// is nothing for `std::mem::forget` to ignore.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x: i32 = 42; // i32 implements Copy
-    /// std::mem::forget(x) // A copy of x is passed to the function, leaving the
-    ///                     // original unaffected
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FORGET_COPY,
-    correctness,
-    "calls to `std::mem::forget` with a value that implements Copy"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `std::mem::drop` with a value that does not implement `Drop`.
@@ -104,15 +76,12 @@ declare_clippy_lint! {
     "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
 }
 
-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`. \
                                  Dropping such a type only extends its contained lifetimes";
 const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
                                    Forgetting such a type is the same as dropping it";
 
 declare_lint_pass!(DropForgetRef => [
-    FORGET_COPY,
     DROP_NON_DROP,
     FORGET_NON_DROP,
     UNDROPPED_MANUALLY_DROPS
@@ -129,11 +98,11 @@ 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, drop_copy, forget_ref
+                // early return for uplifted lints: drop_ref, drop_copy, forget_ref, forget_copy
                 sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => return,
                 sym::mem_forget if arg_ty.is_ref() => return,
                 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_forget if is_copy => return,
                 sym::mem_drop if is_type_lang_item(cx, arg_ty, LangItem::ManuallyDrop) => {
                     span_lint_and_help(
                         cx,

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

@@ -37,6 +37,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("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"),
+    ("clippy::forget_copy", "forget_copy"),
     ("clippy::forget_ref", "forget_ref"),
     ("clippy::into_iter_on_array", "array_into_iter"),
     ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),

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

@@ -5,7 +5,7 @@ use std::mem as memstuff;
 use std::mem::forget as forgetSomething;
 
 #[warn(clippy::mem_forget)]
-#[allow(clippy::forget_copy)]
+#[allow(forget_copy)]
 fn main() {
     let five: i32 = 5;
     forgetSomething(five);

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

@@ -32,6 +32,7 @@
 #![allow(drop_copy)]
 #![allow(drop_ref)]
 #![allow(for_loops_over_fallibles)]
+#![allow(forget_copy)]
 #![allow(forget_ref)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
@@ -79,6 +80,7 @@
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]
+#![warn(forget_copy)]
 #![warn(forget_ref)]
 #![warn(array_into_iter)]
 #![warn(invalid_atomic_ordering)]

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

@@ -32,6 +32,7 @@
 #![allow(drop_copy)]
 #![allow(drop_ref)]
 #![allow(for_loops_over_fallibles)]
+#![allow(forget_copy)]
 #![allow(forget_ref)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
@@ -79,6 +80,7 @@
 #![warn(clippy::for_loop_over_option)]
 #![warn(clippy::for_loop_over_result)]
 #![warn(clippy::for_loops_over_fallibles)]
+#![warn(clippy::forget_copy)]
 #![warn(clippy::forget_ref)]
 #![warn(clippy::into_iter_on_array)]
 #![warn(clippy::invalid_atomic_ordering)]