Split up `drop_forget_ref` ui test

5 files changed, 275 insertions, 244 deletions

diff --git a/tests/ui/drop_forget_ref.stderr b/tests/ui/drop_forget_ref.stderr
deleted file mode 100644
index b51c45ea5ee..00000000000
--- a/tests/ui/drop_forget_ref.stderr
+++ /dev/null
@@ -1,220 +0,0 @@
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:9:5
-   |
-LL |     drop(&SomeStruct);
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::drop-ref` implied by `-D warnings`
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:9:10
-   |
-LL |     drop(&SomeStruct);
-   |          ^^^^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:10:5
-   |
-LL |     forget(&SomeStruct);
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::forget-ref` implied by `-D warnings`
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:10:12
-   |
-LL |     forget(&SomeStruct);
-   |            ^^^^^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:13:5
-   |
-LL |     drop(&owned1);
-   |     ^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:13:10
-   |
-LL |     drop(&owned1);
-   |          ^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:14:5
-   |
-LL |     drop(&&owned1);
-   |     ^^^^^^^^^^^^^^
-   |
-note: argument has type `&&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:14:10
-   |
-LL |     drop(&&owned1);
-   |          ^^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:15:5
-   |
-LL |     drop(&mut owned1);
-   |     ^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_forget_ref.rs:15:10
-   |
-LL |     drop(&mut owned1);
-   |          ^^^^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:18:5
-   |
-LL |     forget(&owned2);
-   |     ^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:18:12
-   |
-LL |     forget(&owned2);
-   |            ^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:19:5
-   |
-LL |     forget(&&owned2);
-   |     ^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:19:12
-   |
-LL |     forget(&&owned2);
-   |            ^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:20:5
-   |
-LL |     forget(&mut owned2);
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_forget_ref.rs:20:12
-   |
-LL |     forget(&mut owned2);
-   |            ^^^^^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:24:5
-   |
-LL |     drop(reference1);
-   |     ^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:24:10
-   |
-LL |     drop(reference1);
-   |          ^^^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:25:5
-   |
-LL |     forget(&*reference1);
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:25:12
-   |
-LL |     forget(&*reference1);
-   |            ^^^^^^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:28:5
-   |
-LL |     drop(reference2);
-   |     ^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_forget_ref.rs:28:10
-   |
-LL |     drop(reference2);
-   |          ^^^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:30:5
-   |
-LL |     forget(reference3);
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_forget_ref.rs:30:12
-   |
-LL |     forget(reference3);
-   |            ^^^^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:33:5
-   |
-LL |     drop(reference4);
-   |     ^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:33:10
-   |
-LL |     drop(reference4);
-   |          ^^^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:34:5
-   |
-LL |     forget(reference4);
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:34:12
-   |
-LL |     forget(reference4);
-   |            ^^^^^^^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:39:5
-   |
-LL |     drop(&val);
-   |     ^^^^^^^^^^
-   |
-note: argument has type `&T`
-  --> $DIR/drop_forget_ref.rs:39:10
-   |
-LL |     drop(&val);
-   |          ^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:45:5
-   |
-LL |     forget(&val);
-   |     ^^^^^^^^^^^^
-   |
-note: argument has type `&T`
-  --> $DIR/drop_forget_ref.rs:45:12
-   |
-LL |     forget(&val);
-   |            ^^^^
-
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:53:5
-   |
-LL |     std::mem::drop(&SomeStruct);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:53:20
-   |
-LL |     std::mem::drop(&SomeStruct);
-   |                    ^^^^^^^^^^^
-
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-  --> $DIR/drop_forget_ref.rs:56:5
-   |
-LL |     std::mem::forget(&SomeStruct);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: argument has type `&SomeStruct`
-  --> $DIR/drop_forget_ref.rs:56:22
-   |
-LL |     std::mem::forget(&SomeStruct);
-   |                      ^^^^^^^^^^^
-
-error: aborting due to 18 previous errors
-
diff --git a/tests/ui/drop_forget_ref.rs b/tests/ui/drop_ref.rs
index aad996c0376..9181d789d4f 100644
--- a/tests/ui/drop_forget_ref.rs
+++ b/tests/ui/drop_ref.rs
@@ -1,37 +1,27 @@
-#![warn(clippy::drop_ref, clippy::forget_ref)]
-#![allow(clippy::toplevel_ref_arg, clippy::similar_names, clippy::needless_pass_by_value)]
+#![warn(clippy::drop_ref)]
+#![allow(clippy::toplevel_ref_arg)]
 
-use std::mem::{drop, forget};
+use std::mem::drop;
 
 struct SomeStruct;
 
 fn main() {
     drop(&SomeStruct);
-    forget(&SomeStruct);
 
     let mut owned1 = SomeStruct;
     drop(&owned1);
     drop(&&owned1);
     drop(&mut owned1);
     drop(owned1); //OK
-    let mut owned2 = SomeStruct;
-    forget(&owned2);
-    forget(&&owned2);
-    forget(&mut owned2);
-    forget(owned2); //OK
 
     let reference1 = &SomeStruct;
     drop(reference1);
-    forget(&*reference1);
 
     let reference2 = &mut SomeStruct;
     drop(reference2);
-    let reference3 = &mut SomeStruct;
-    forget(reference3);
 
-    let ref reference4 = SomeStruct;
-    drop(reference4);
-    forget(reference4);
+    let ref reference3 = SomeStruct;
+    drop(reference3);
 }
 
 #[allow(dead_code)]
@@ -41,19 +31,10 @@ fn test_generic_fn_drop<T>(val: T) {
 }
 
 #[allow(dead_code)]
-fn test_generic_fn_forget<T>(val: T) {
-    forget(&val);
-    forget(val); //OK
-}
-
-#[allow(dead_code)]
 fn test_similarly_named_function() {
     fn drop<T>(_val: T) {}
     drop(&SomeStruct); //OK; call to unrelated function which happens to have the same name
     std::mem::drop(&SomeStruct);
-    fn forget<T>(_val: T) {}
-    forget(&SomeStruct); //OK; call to unrelated function which happens to have the same name
-    std::mem::forget(&SomeStruct);
 }
 
 #[derive(Copy, Clone)]
diff --git a/tests/ui/drop_ref.stderr b/tests/ui/drop_ref.stderr
new file mode 100644
index 00000000000..35ae88b78a4
--- /dev/null
+++ b/tests/ui/drop_ref.stderr
@@ -0,0 +1,111 @@
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:9:5
+   |
+LL |     drop(&SomeStruct);
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::drop-ref` implied by `-D warnings`
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_ref.rs:9:10
+   |
+LL |     drop(&SomeStruct);
+   |          ^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:12:5
+   |
+LL |     drop(&owned1);
+   |     ^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_ref.rs:12:10
+   |
+LL |     drop(&owned1);
+   |          ^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:13:5
+   |
+LL |     drop(&&owned1);
+   |     ^^^^^^^^^^^^^^
+   |
+note: argument has type `&&SomeStruct`
+  --> $DIR/drop_ref.rs:13:10
+   |
+LL |     drop(&&owned1);
+   |          ^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:14:5
+   |
+LL |     drop(&mut owned1);
+   |     ^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&mut SomeStruct`
+  --> $DIR/drop_ref.rs:14:10
+   |
+LL |     drop(&mut owned1);
+   |          ^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:18:5
+   |
+LL |     drop(reference1);
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_ref.rs:18:10
+   |
+LL |     drop(reference1);
+   |          ^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:21:5
+   |
+LL |     drop(reference2);
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&mut SomeStruct`
+  --> $DIR/drop_ref.rs:21:10
+   |
+LL |     drop(reference2);
+   |          ^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:24:5
+   |
+LL |     drop(reference3);
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_ref.rs:24:10
+   |
+LL |     drop(reference3);
+   |          ^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:29:5
+   |
+LL |     drop(&val);
+   |     ^^^^^^^^^^
+   |
+note: argument has type `&T`
+  --> $DIR/drop_ref.rs:29:10
+   |
+LL |     drop(&val);
+   |          ^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+  --> $DIR/drop_ref.rs:37:5
+   |
+LL |     std::mem::drop(&SomeStruct);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/drop_ref.rs:37:20
+   |
+LL |     std::mem::drop(&SomeStruct);
+   |                    ^^^^^^^^^^^
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/forget_ref.rs b/tests/ui/forget_ref.rs
new file mode 100644
index 00000000000..447fdbe1fac
--- /dev/null
+++ b/tests/ui/forget_ref.rs
@@ -0,0 +1,48 @@
+#![warn(clippy::forget_ref)]
+#![allow(clippy::toplevel_ref_arg)]
+
+use std::mem::forget;
+
+struct SomeStruct;
+
+fn main() {
+    forget(&SomeStruct);
+
+    let mut owned = SomeStruct;
+    forget(&owned);
+    forget(&&owned);
+    forget(&mut owned);
+    forget(owned); //OK
+
+    let reference1 = &SomeStruct;
+    forget(&*reference1);
+
+    let reference2 = &mut SomeStruct;
+    forget(reference2);
+
+    let ref reference3 = SomeStruct;
+    forget(reference3);
+}
+
+#[allow(dead_code)]
+fn test_generic_fn_forget<T>(val: T) {
+    forget(&val);
+    forget(val); //OK
+}
+
+#[allow(dead_code)]
+fn test_similarly_named_function() {
+    fn forget<T>(_val: T) {}
+    forget(&SomeStruct); //OK; call to unrelated function which happens to have the same name
+    std::mem::forget(&SomeStruct);
+}
+
+#[derive(Copy, Clone)]
+pub struct Error;
+fn produce_half_owl_error() -> Result<(), Error> {
+    Ok(())
+}
+
+fn produce_half_owl_ok() -> Result<bool, ()> {
+    Ok(true)
+}
diff --git a/tests/ui/forget_ref.stderr b/tests/ui/forget_ref.stderr
new file mode 100644
index 00000000000..f90bcc2762c
--- /dev/null
+++ b/tests/ui/forget_ref.stderr
@@ -0,0 +1,111 @@
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:9:5
+   |
+LL |     forget(&SomeStruct);
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::forget-ref` implied by `-D warnings`
+note: argument has type `&SomeStruct`
+  --> $DIR/forget_ref.rs:9:12
+   |
+LL |     forget(&SomeStruct);
+   |            ^^^^^^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:12:5
+   |
+LL |     forget(&owned);
+   |     ^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/forget_ref.rs:12:12
+   |
+LL |     forget(&owned);
+   |            ^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:13:5
+   |
+LL |     forget(&&owned);
+   |     ^^^^^^^^^^^^^^^
+   |
+note: argument has type `&&SomeStruct`
+  --> $DIR/forget_ref.rs:13:12
+   |
+LL |     forget(&&owned);
+   |            ^^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:14:5
+   |
+LL |     forget(&mut owned);
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&mut SomeStruct`
+  --> $DIR/forget_ref.rs:14:12
+   |
+LL |     forget(&mut owned);
+   |            ^^^^^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:18:5
+   |
+LL |     forget(&*reference1);
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/forget_ref.rs:18:12
+   |
+LL |     forget(&*reference1);
+   |            ^^^^^^^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:21:5
+   |
+LL |     forget(reference2);
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&mut SomeStruct`
+  --> $DIR/forget_ref.rs:21:12
+   |
+LL |     forget(reference2);
+   |            ^^^^^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:24:5
+   |
+LL |     forget(reference3);
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/forget_ref.rs:24:12
+   |
+LL |     forget(reference3);
+   |            ^^^^^^^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:29:5
+   |
+LL |     forget(&val);
+   |     ^^^^^^^^^^^^
+   |
+note: argument has type `&T`
+  --> $DIR/forget_ref.rs:29:12
+   |
+LL |     forget(&val);
+   |            ^^^^
+
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+  --> $DIR/forget_ref.rs:37:5
+   |
+LL |     std::mem::forget(&SomeStruct);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&SomeStruct`
+  --> $DIR/forget_ref.rs:37:22
+   |
+LL |     std::mem::forget(&SomeStruct);
+   |                      ^^^^^^^^^^^
+
+error: aborting due to 9 previous errors
+