fix: unnecessary_lazy_evaluations suggests wrongly for async closure

Author: profetia

clippy_lints/src/methods/unnecessary_lazy_eval.rs

@@ -4,7 +4,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{eager_or_lazy, is_from_proc_macro, usage};
 use hir::FnRetTy;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{self as hir, ClosureKind};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -24,7 +24,12 @@ pub(super) fn check<'tcx>(
     let is_bool = cx.typeck_results().expr_ty(recv).is_bool();
 
     if (is_option || is_result || is_bool)
-        && let hir::ExprKind::Closure(&hir::Closure { body, fn_decl, .. }) = arg.kind
+        && let hir::ExprKind::Closure(&hir::Closure {
+            body,
+            fn_decl,
+            kind: ClosureKind::Closure,
+            ..
+        }) = arg.kind
     {
         let body = cx.tcx.hir_body(body);
         let body_expr = &body.value;

tests/ui/unnecessary_lazy_eval.fixed

@@ -321,3 +321,34 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     let _x = false.then_some(f1 + f2);
     //~^ unnecessary_lazy_evaluations
 }
+
+mod issue14578 {
+    use std::future::Future;
+
+    pub struct OptionFuture<F> {
+        inner: Option<F>,
+    }
+
+    impl<F: Future> Future for OptionFuture<F> {
+        type Output = Option<F::Output>;
+
+        fn poll(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<Self::Output> {
+            todo!()
+        }
+    }
+
+    impl<T> From<Option<T>> for OptionFuture<T> {
+        fn from(option: Option<T>) -> Self {
+            todo!()
+        }
+    }
+
+    async fn do_something() {
+        let random_bool = false;
+        let may_take_while: OptionFuture<_> = random_bool.then(async || take_while(42).await).into();
+    }
+
+    async fn take_while<T>(value: T) -> T {
+        todo!()
+    }
+}

tests/ui/unnecessary_lazy_eval.rs

@@ -321,3 +321,34 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     let _x = false.then(|| f1 + f2);
     //~^ unnecessary_lazy_evaluations
 }
+
+mod issue14578 {
+    use std::future::Future;
+
+    pub struct OptionFuture<F> {
+        inner: Option<F>,
+    }
+
+    impl<F: Future> Future for OptionFuture<F> {
+        type Output = Option<F::Output>;
+
+        fn poll(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<Self::Output> {
+            todo!()
+        }
+    }
+
+    impl<T> From<Option<T>> for OptionFuture<T> {
+        fn from(option: Option<T>) -> Self {
+            todo!()
+        }
+    }
+
+    async fn do_something() {
+        let random_bool = false;
+        let may_take_while: OptionFuture<_> = random_bool.then(async || take_while(42).await).into();
+    }
+
+    async fn take_while<T>(value: T) -> T {
+        todo!()
+    }
+}