new lint: missing_must_use_on_future_types

CHANGELOG.md

@@ -5827,6 +5827,7 @@ Released 2018-09-13
 [`missing_errors_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc
 [`missing_fields_in_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_fields_in_debug
 [`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
+[`missing_must_use_on_future_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_must_use_on_future_types
 [`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`missing_spin_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_spin_loop

clippy_lints/src/declared_lints.rs

@@ -529,6 +529,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES_INFO,
     crate::missing_fields_in_debug::MISSING_FIELDS_IN_DEBUG_INFO,
     crate::missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS_INFO,
+    crate::missing_must_use_on_future_types::MISSING_MUST_USE_ON_FUTURE_TYPES_INFO,
     crate::missing_trait_methods::MISSING_TRAIT_METHODS_INFO,
     crate::mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION_INFO,
     crate::mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION_INFO,

clippy_lints/src/lib.rs

@@ -243,6 +243,7 @@ mod missing_doc;
 mod missing_enforced_import_rename;
 mod missing_fields_in_debug;
 mod missing_inline;
+mod missing_must_use_on_future_types;
 mod missing_trait_methods;
 mod mixed_read_write_in_expression;
 mod module_style;
@@ -974,5 +975,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(arbitrary_source_item_ordering::ArbitrarySourceItemOrdering::new(conf)));
     store.register_late_pass(|_| Box::new(unneeded_struct_pattern::UnneededStructPattern));
     store.register_late_pass(|_| Box::<unnecessary_semicolon::UnnecessarySemicolon>::default());
+    store.register_late_pass(|_| Box::new(missing_must_use_on_future_types::MissingMustUseOnFutureTypes));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

clippy_lints/src/missing_must_use_on_future_types.rs

@@ -0,0 +1,101 @@
+use rustc_errors::Applicability;
+use rustc_hir::{Impl, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::declare_lint_pass;
+use rustc_span::sym;
+
+use clippy_utils::diagnostics::span_lint_and_then;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a missing `#[must_use]` attribute on types
+    /// that implement `Future`.
+    ///
+    /// ### Why is this bad?
+    /// Futures must be polled for work to be done and it
+    /// can be easy to accidentally forget.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct Foo;
+    ///
+    /// // impl Future for Foo { ... }
+    /// # impl Future for Foo {
+    /// #     type Output = ();
+    /// #
+    /// #     fn poll(
+    /// #         self: std::pin::Pin<&mut Self>,
+    /// #         _cx: &mut std::task::Context<'_>,
+    /// #     ) -> std::task::Poll<Self::Output> {
+    /// #         std::task::Poll::Ready(())
+    /// #     }
+    /// # }
+    ///
+    /// fn foo() -> Foo { Foo }
+    ///
+    /// fn main() {
+    ///     foo();
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[must_use]
+    /// struct Foo;
+    ///
+    /// // impl Future for Foo { ... }
+    /// # impl Future for Foo {
+    /// #     type Output = ();
+    /// #
+    /// #     fn poll(
+    /// #         self: std::pin::Pin<&mut Self>,
+    /// #         _cx: &mut std::task::Context<'_>,
+    /// #     ) -> std::task::Poll<Self::Output> {
+    /// #         std::task::Poll::Ready(())
+    /// #     }
+    /// # }
+    ///
+    /// fn foo() -> Foo { Foo }
+    ///
+    /// fn main() {
+    ///     foo();
+    /// }
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MISSING_MUST_USE_ON_FUTURE_TYPES,
+    style,
+    "missing `#[must_use]` annotation on a type implementing `Future`"
+}
+
+declare_lint_pass!(MissingMustUseOnFutureTypes => [MISSING_MUST_USE_ON_FUTURE_TYPES]);
+
+impl<'tcx> LateLintPass<'tcx> for MissingMustUseOnFutureTypes {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if let ItemKind::Impl(Impl {
+            of_trait: Some(trait_ref),
+            ..
+        }) = item.kind
+            && let Some(trait_def_id) = trait_ref.trait_def_id()
+            && let Some(future_def_id) = cx.tcx.lang_items().future_trait()
+            && trait_def_id == future_def_id
+            && let &ty::Adt(adt_def, _) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind()
+            && cx.tcx.get_attr(adt_def.did(), sym::must_use).is_none()
+        {
+            let adt_span = cx.tcx.def_span(adt_def.did());
+            span_lint_and_then(
+                cx,
+                MISSING_MUST_USE_ON_FUTURE_TYPES,
+                adt_span,
+                "this struct implements `Future` but is missing a `#[must_use]` attribute",
+                |diag| {
+                    diag.span_suggestion(
+                        adt_span.shrink_to_lo(),
+                        "add the attribute",
+                        "#[must_use]\n",
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+}

tests/ui/async_yields_async.fixed

@@ -1,5 +1,5 @@
 #![warn(clippy::async_yields_async)]
-#![allow(clippy::redundant_async_block)]
+#![allow(clippy::redundant_async_block, clippy::missing_must_use_on_future_types)]
 
 use core::future::Future;
 use core::pin::Pin;

tests/ui/async_yields_async.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::async_yields_async)]
-#![allow(clippy::redundant_async_block)]
+#![allow(clippy::redundant_async_block, clippy::missing_must_use_on_future_types)]
 
 use core::future::Future;
 use core::pin::Pin;

tests/ui/crashes/ice-13862.rs

@@ -1,5 +1,6 @@
 #![crate_type = "lib"]
 #![no_std]
+#![allow(clippy::missing_must_use_on_future_types)]
 
 use core::future::Future;
 use core::pin::Pin;

tests/ui/missing_must_use_on_future_types.fixed

@@ -0,0 +1,118 @@
+#![warn(clippy::missing_must_use_on_future_types)]
+#![allow(path_statements, unused, clippy::no_effect)]
+
+use std::fmt::Display;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+// basic struct case
+#[must_use]
+struct BasicStruct;
+
+impl Future for BasicStruct {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// basic enum case
+#[must_use]
+enum BasicEnum {
+    Var1,
+    Var2,
+}
+
+impl Future for BasicEnum {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// should be ignored if type doesn't implement `Future`
+struct NonFuture;
+
+// should still trigger if a type only sometimes implements `Future`
+#[must_use]
+struct SometimesFuture<T>(PhantomData<T>);
+
+impl<T: Copy> Future for SometimesFuture<T> {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// should be ignored on trait objects
+trait Trait {}
+
+impl Future for dyn Trait {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+struct TraitImpl {}
+impl Trait for TraitImpl {}
+
+fn trait_obj() -> Box<dyn Trait> {
+    Box::new(TraitImpl {})
+}
+
+// struct with multiple fields and impls
+#[derive(Debug)]
+#[must_use]
+pub struct ComplexStruct {
+    x: usize,
+    y: &'static str,
+}
+
+impl ComplexStruct {
+    fn sum(&self) -> usize {
+        self.x + self.y.len()
+    }
+}
+
+impl Display for ComplexStruct {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "complex")
+    }
+}
+
+impl Future for ComplexStruct {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// should be ignored on already #[must_use] struct
+#[must_use]
+struct AlreadyMustUse;
+
+impl Future for AlreadyMustUse {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+fn main() {
+    BasicStruct;
+    BasicEnum::Var2;
+    NonFuture;
+    SometimesFuture::<String>(PhantomData);
+    trait_obj();
+    ComplexStruct { x: 42, y: "complex" };
+    AlreadyMustUse;
+}

tests/ui/missing_must_use_on_future_types.rs

@@ -0,0 +1,114 @@
+#![warn(clippy::missing_must_use_on_future_types)]
+#![allow(path_statements, unused, clippy::no_effect)]
+
+use std::fmt::Display;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+// basic struct case
+struct BasicStruct;
+
+impl Future for BasicStruct {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// basic enum case
+enum BasicEnum {
+    Var1,
+    Var2,
+}
+
+impl Future for BasicEnum {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// should be ignored if type doesn't implement `Future`
+struct NonFuture;
+
+// should still trigger if a type only sometimes implements `Future`
+struct SometimesFuture<T>(PhantomData<T>);
+
+impl<T: Copy> Future for SometimesFuture<T> {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// should be ignored on trait objects
+trait Trait {}
+
+impl Future for dyn Trait {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+struct TraitImpl {}
+impl Trait for TraitImpl {}
+
+fn trait_obj() -> Box<dyn Trait> {
+    Box::new(TraitImpl {})
+}
+
+// struct with multiple fields and impls
+#[derive(Debug)]
+pub struct ComplexStruct {
+    x: usize,
+    y: &'static str,
+}
+
+impl ComplexStruct {
+    fn sum(&self) -> usize {
+        self.x + self.y.len()
+    }
+}
+
+impl Display for ComplexStruct {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "complex")
+    }
+}
+
+impl Future for ComplexStruct {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+// should be ignored on already #[must_use] struct
+#[must_use]
+struct AlreadyMustUse;
+
+impl Future for AlreadyMustUse {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
+}
+
+fn main() {
+    BasicStruct;
+    BasicEnum::Var2;
+    NonFuture;
+    SometimesFuture::<String>(PhantomData);
+    trait_obj();
+    ComplexStruct { x: 42, y: "complex" };
+    AlreadyMustUse;
+}