Drop uplifted clippy::forget_ref

Author: Urgau

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

@@ -134,7 +134,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     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::FORGET_REF_INFO,
     crate::drop_forget_ref::UNDROPPED_MANUALLY_DROPS_INFO,
     crate::duplicate_mod::DUPLICATE_MOD_INFO,
     crate::else_if_without_else::ELSE_IF_WITHOUT_ELSE_INFO,

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

@@ -7,28 +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 reference
-    /// instead of an owned value.
-    ///
-    /// ### Why is this bad?
-    /// Calling `forget` on a reference will only forget the
-    /// reference itself, which is a no-op. It will not forget the underlying
-    /// referenced
-    /// value, which is likely what was intended.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = Box::new(1);
-    /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FORGET_REF,
-    correctness,
-    "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::forget` with a value that
@@ -126,8 +104,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 FORGET_REF_SUMMARY: &str = "calls to `std::mem::forget` with a reference instead of an owned value. \
-                                  Forgetting a reference does nothing";
 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`. \
@@ -136,7 +112,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 => [
-    FORGET_REF,
     FORGET_COPY,
     DROP_NON_DROP,
     FORGET_NON_DROP,
@@ -154,9 +129,9 @@ 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
+                // early return for uplifted lints: drop_ref, drop_copy, forget_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_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_drop if is_type_lang_item(cx, arg_ty, LangItem::ManuallyDrop) => {

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

@@ -36,6 +36,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_ref", "forget_ref"),
     ("clippy::into_iter_on_array", "array_into_iter"),
     ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
     ("clippy::invalid_ref", "invalid_value"),

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

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

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

@@ -84,6 +84,18 @@ note: argument has type `SomeStruct`
 LL |     forget(s2);
    |            ^^
 
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:41:5
+   |
+LL |     forget(s3);
+   |     ^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_forget_copy.rs:41:12
+   |
+LL |     forget(s3);
+   |            ^^
+
 error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:42:5
    |
@@ -96,6 +108,18 @@ note: argument has type `SomeStruct`
 LL |     forget(s4);
    |            ^^
 
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:43:5
+   |
+LL |     forget(s5);
+   |     ^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_forget_copy.rs:43:12
+   |
+LL |     forget(s5);
+   |            ^^
+
 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
    |
@@ -120,6 +144,42 @@ note: argument has type `&AnotherStruct`
 LL |     drop(a4);
    |          ^^
 
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:60:5
+   |
+LL |     forget(a2);
+   |     ^^^^^^^^^^
+   |
+note: argument has type `&AnotherStruct`
+  --> $DIR/drop_forget_copy.rs:60:12
+   |
+LL |     forget(a2);
+   |            ^^
+
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:62:5
+   |
+LL |     forget(a3);
+   |     ^^^^^^^^^^
+   |
+note: argument has type `&AnotherStruct`
+  --> $DIR/drop_forget_copy.rs:62:12
+   |
+LL |     forget(a3);
+   |            ^^
+
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:63:5
+   |
+LL |     forget(a4);
+   |     ^^^^^^^^^^
+   |
+note: argument has type `&AnotherStruct`
+  --> $DIR/drop_forget_copy.rs:63:12
+   |
+LL |     forget(a4);
+   |            ^^
+
 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
    |
@@ -229,5 +289,5 @@ note: argument has type `i32`
 LL |         4 => drop(2),                           // Lint, not a fn/method call
    |                   ^
 
-error: aborting due to 19 previous errors
+error: aborting due to 24 previous errors
 

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

@@ -31,6 +31,7 @@
 #![allow(drop_copy)]
 #![allow(drop_ref)]
 #![allow(for_loops_over_fallibles)]
+#![allow(forget_ref)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
 #![allow(invalid_value)]
@@ -75,6 +76,7 @@
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]
+#![warn(forget_ref)]
 #![warn(array_into_iter)]
 #![warn(invalid_atomic_ordering)]
 #![warn(invalid_value)]

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

@@ -31,6 +31,7 @@
 #![allow(drop_copy)]
 #![allow(drop_ref)]
 #![allow(for_loops_over_fallibles)]
+#![allow(forget_ref)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
 #![allow(invalid_value)]
@@ -75,6 +76,7 @@
 #![warn(clippy::for_loop_over_option)]
 #![warn(clippy::for_loop_over_result)]
 #![warn(clippy::for_loops_over_fallibles)]
+#![warn(clippy::forget_ref)]
 #![warn(clippy::into_iter_on_array)]
 #![warn(clippy::invalid_atomic_ordering)]
 #![warn(clippy::invalid_ref)]