Add a lint for forgetting futures

CHANGELOG.md

@@ -6747,6 +6747,7 @@ Released 2018-09-13
 [`for_loop_over_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loop_over_result
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
+[`forget_future`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_future
 [`forget_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_non_drop
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`format_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_collect

clippy_lints/src/declared_lints.rs

@@ -133,6 +133,7 @@ pub static LINTS: &[&::declare_clippy_lint::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_FUTURE_INFO,
     crate::drop_forget_ref::FORGET_NON_DROP_INFO,
     crate::drop_forget_ref::MEM_FORGET_INFO,
     crate::duplicate_mod::DUPLICATE_MOD_INFO,

clippy_lints/src/drop_forget_ref.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_must_use_func_call;
 use clippy_utils::res::MaybeDef;
-use clippy_utils::ty::{is_copy, is_must_use_ty};
+use clippy_utils::ty::{implements_trait, is_copy, is_must_use_ty};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -28,6 +28,29 @@ declare_clippy_lint! {
     "call to `std::mem::drop` with a value which does not implement `Drop`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for not executing `Drop` on a `Future`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Futures use drop to be signalled that they were cancelled and should clean up their resources.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// std::mem::forget(async {});
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// std::mem::drop(async {});
+    /// ```
+    #[clippy::version = "1.97.0"]
+    pub FORGET_FUTURE,
+    suspicious,
+    "`mem::forget` usage on `Future` types, likely to cause problems with cancelation"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `std::mem::forget` with a value that does not implement `Drop`.
@@ -70,12 +93,18 @@ declare_clippy_lint! {
     "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
 }
 
-declare_lint_pass!(DropForgetRef => [DROP_NON_DROP, FORGET_NON_DROP, MEM_FORGET]);
+declare_lint_pass!(DropForgetRef => [
+    DROP_NON_DROP,
+    FORGET_FUTURE,
+    FORGET_NON_DROP,
+    MEM_FORGET,
+]);
 
 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";
+const FORGET_FUTURE_SUMMARY: &str = "forgetting a Future might cause problems with cancelation";
 
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -104,6 +133,14 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                     (DROP_NON_DROP, DROP_NON_DROP_SUMMARY.into(), Some(arg.span))
                 },
                 sym::mem_forget => {
+                    if let Some(future_trait) = cx.tcx.lang_items().future_trait()
+                        && implements_trait(cx, arg_ty, future_trait, &[])
+                    {
+                        span_lint_and_then(cx, FORGET_FUTURE, expr.span, FORGET_FUTURE_SUMMARY, |diag| {
+                            diag.span_note(arg.span, format!("argument has type `{arg_ty}`"));
+                        });
+                    }
+
                     if arg_ty.needs_drop(cx.tcx, cx.typing_env()) {
                         (
                             MEM_FORGET,

tests/ui/forget_future.rs

@@ -0,0 +1,34 @@
+#![warn(clippy::forget_future)]
+
+use core::mem;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+fn main() {
+    let fut = foo();
+    mem::forget(fut);
+    //~^ forget_future
+
+    mem::forget(async {});
+    //~^ forget_future
+
+    let fut = MyFuture;
+    mem::forget(fut);
+    //~^ forget_future
+}
+
+async fn foo() {}
+
+struct MyFuture;
+
+impl Future for MyFuture {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+impl Drop for MyFuture {
+    fn drop(&mut self) {}
+}

tests/ui/forget_future.stderr

@@ -0,0 +1,40 @@
+error: forgetting a Future might cause problems with cancelation
+  --> tests/ui/forget_future.rs:9:5
+   |
+LL |     mem::forget(fut);
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: argument has type `impl std::future::Future<Output = ()>`
+  --> tests/ui/forget_future.rs:9:17
+   |
+LL |     mem::forget(fut);
+   |                 ^^^
+   = note: `-D clippy::forget-future` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::forget_future)]`
+
+error: forgetting a Future might cause problems with cancelation
+  --> tests/ui/forget_future.rs:12:5
+   |
+LL |     mem::forget(async {});
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `{async block@tests/ui/forget_future.rs:12:17: 12:22}`
+  --> tests/ui/forget_future.rs:12:17
+   |
+LL |     mem::forget(async {});
+   |                 ^^^^^^^^
+
+error: forgetting a Future might cause problems with cancelation
+  --> tests/ui/forget_future.rs:16:5
+   |
+LL |     mem::forget(fut);
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: argument has type `MyFuture`
+  --> tests/ui/forget_future.rs:16:17
+   |
+LL |     mem::forget(fut);
+   |                 ^^^
+
+error: aborting due to 3 previous errors
+

tests/ui/mem_forget.rs

@@ -5,7 +5,7 @@ use std::mem as memstuff;
 use std::mem::forget as forgetSomething;
 
 #[warn(clippy::mem_forget)]
-#[allow(forgetting_copy_types)]
+#[allow(forgetting_copy_types, clippy::forget_future)]
 fn main() {
     let five: i32 = 5;
     forgetSomething(five);
@@ -26,5 +26,9 @@ fn main() {
     std::mem::forget(string);
     //~^ mem_forget
 
+    let fut = async {};
+    std::mem::forget(fut);
+    //~^ mem_forget
+
     std::mem::forget(7);
 }

tests/ui/mem_forget.stderr

@@ -32,5 +32,13 @@ LL |     std::mem::forget(string);
    |
    = note: argument has type `std::string::String`
 
-error: aborting due to 4 previous errors
+error: usage of `mem::forget` on type with `Drop` fields
+  --> tests/ui/mem_forget.rs:30:5
+   |
+LL |     std::mem::forget(fut);
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: argument has type `{async block@tests/ui/mem_forget.rs:29:15: 29:20}`
+
+error: aborting due to 5 previous errors