Bless clippy.

Author: cjgillot

src/tools/clippy/clippy_lints/src/doc/missing_headers.rs

@@ -83,7 +83,7 @@ pub fn check(
                 Some(owner_id.def_id.to_def_id()),
                 &[],
             )
-            && let ty::Coroutine(_, subs) = ret_ty.kind()
+            && let Some((_, subs)) = cx.tcx.try_unwrap_desugared_coroutine(ret_ty)
             && subs.as_coroutine().return_ty().is_diag_item(cx, sym::Result)
         {
             span_lint(

src/tools/clippy/clippy_lints/src/implicit_return.rs

@@ -229,7 +229,6 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
         _: LocalDefId,
     ) {
         if (!matches!(kind, FnKind::Closure) && matches!(decl.output, FnRetTy::DefaultReturn(_)))
-            || !span.eq_ctxt(body.value.span)
             || span.in_external_macro(cx.sess().source_map())
         {
             return;
@@ -251,7 +250,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
             body.value
         };
 
-        if is_from_proc_macro(cx, expr) {
+        if is_from_proc_macro(cx, expr) || !span.eq_ctxt(expr.span) {
             return;
         }
         lint_implicit_returns(cx, expr, expr.span.ctxt(), None);

src/tools/clippy/clippy_lints/src/manual_async_fn.rs

@@ -1,11 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::desugared_async_block;
 use clippy_utils::source::{SpanRangeExt, position_before_rarrow, snippet_block};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    Block, Body, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, FnDecl,
-    FnRetTy, GenericBound, Node, OpaqueTy, TraitRef, Ty, TyKind,
-};
+use rustc_hir::{Body, ExprKind, FnDecl, FnRetTy, GenericBound, Node, OpaqueTy, TraitRef, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::ty;
@@ -59,7 +57,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
             // Check that the body of the function consists of one async block
             && let ExprKind::Block(block, _) = body.value.kind
             && block.stmts.is_empty()
-            && let Some(closure_body) = desugared_async_block(cx, block)
+            && let Some(body_expr) = block.expr
+            && let Some((_, closure_body)) = desugared_async_block(cx, body_expr)
             && let Some(vis_span_opt) = match cx.tcx.hir_node_by_def_id(fn_def_id) {
                 Node::Item(item) => Some(Some(item.vis_span)),
                 Node::ImplItem(impl_item) => Some(impl_item.vis_span()),
@@ -165,20 +164,6 @@ fn captures_all_lifetimes(cx: &LateContext<'_>, fn_def_id: LocalDefId, opaque_de
     num_captured_lifetimes == num_early_lifetimes + num_late_lifetimes
 }
 
-fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) -> Option<&'tcx Body<'tcx>> {
-    if let Some(&Expr {
-        kind: ExprKind::Closure(&Closure { kind, body, .. }),
-        ..
-    }) = block.expr
-        && let ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, CoroutineSource::Block)) =
-            kind
-    {
-        return Some(cx.tcx.hir_body(body));
-    }
-
-    None
-}
-
 fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'static str, String)> {
     if let TyKind::Tup([]) = output.kind {
         let sugg = "remove the return type";

src/tools/clippy/clippy_lints/src/redundant_async_block.rs

@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{desugar_await, peel_blocks};
+use clippy_utils::{desugar_await, desugared_async_block, peel_blocks};
 use rustc_errors::Applicability;
-use rustc_hir::{Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind};
+use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::UpvarCapture;
 use rustc_session::declare_lint_pass;
@@ -70,27 +70,19 @@ impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
 /// If `expr` is a desugared `async` block, return the original expression if it does not capture
 /// any variable by ref.
 fn desugar_async_block<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Closure(Closure { body, def_id, kind, .. }) = expr.kind
-        && let body = cx.tcx.hir_body(*body)
-        && matches!(
-            kind,
-            ClosureKind::Coroutine(CoroutineKind::Desugared(
-                CoroutineDesugaring::Async,
-                CoroutineSource::Block
-            ))
-        )
-    {
-        cx.typeck_results()
+    let (def_id, body) = desugared_async_block(cx, expr)?;
+    if cx.typeck_results()
             .closure_min_captures
-            .get(def_id)
+            .get(&def_id)
             .is_none_or(|m| {
                 m.values().all(|places| {
                     places
                         .iter()
                         .all(|place| matches!(place.info.capture_kind, UpvarCapture::ByValue))
                 })
             })
-            .then_some(body.value)
+    {
+        Some(body.value)
     } else {
         None
     }

src/tools/clippy/clippy_utils/src/lib.rs

@@ -114,7 +114,7 @@ use rustc_middle::ty::{
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{Ident, Symbol, kw};
-use rustc_span::{InnerSpan, Span, SyntaxContext};
+use rustc_span::{InnerSpan, Span, SyntaxContext, DesugaringKind};
 use source::{SpanRangeExt, walk_span_to_context};
 use visitors::{Visitable, for_each_unconsumed_temporary};
 
@@ -1791,11 +1791,13 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
 
 /// Peels away all the compiler generated code surrounding the body of an async closure.
 pub fn get_async_closure_expr<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Closure(&Closure {
-        body,
-        kind: hir::ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)),
-        ..
-    }) = expr.kind
+    if expr.span.is_desugaring(DesugaringKind::Async)
+        && let ExprKind::Call(_, [closure]) = expr.kind
+        && let ExprKind::Closure(&Closure {
+            body,
+            kind: hir::ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)),
+            ..
+        }) = closure.kind
         && let ExprKind::Block(
             Block {
                 expr:
@@ -1819,6 +1821,20 @@ pub fn get_async_fn_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'t
     get_async_closure_expr(tcx, body.value)
 }
 
+/// If `expr` is a desugared `async` block, return the original expression.
+pub fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<(LocalDefId, &'tcx Body<'tcx>)> {
+    if expr.span.is_desugaring(DesugaringKind::Async)
+        && let ExprKind::Call(_, [closure]) = expr.kind
+        && let ExprKind::Closure(&Closure { kind, body, def_id, .. }) = closure.kind
+        && let hir::ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, CoroutineSource::Block)) =
+            kind
+    {
+        return Some((def_id, cx.tcx.hir_body(body)));
+    }
+
+    None
+}
+
 // check if expr is calling method or function with #[must_use] attribute
 pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let did = match expr.kind {