Bless clippy.

Author: cjgillot

src/tools/clippy/clippy_lints/src/dbg_macro.rs

@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
-use rustc_span::{Span, SyntaxContext};
+use rustc_span::{DesugaringKind, Span, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -58,10 +58,11 @@ impl LateLintPass<'_> for DbgMacro {
         let cur_syntax_ctxt = expr.span.ctxt();
 
         if cur_syntax_ctxt != self.prev_ctxt &&
+            // avoids exprs generated by the desugaring of coroutines,
+            // as they confuse `first_dbg_macro_in_expansion`
+            !expr.span.is_desugaring(DesugaringKind::Async) && !is_coroutine_desugar(expr) &&
             let Some(macro_call) = first_dbg_macro_in_expansion(cx, expr.span) &&
             !macro_call.span.in_external_macro(cx.sess().source_map()) &&
-            // avoids exprs generated by the desugaring of coroutines
-            !is_coroutine_desugar(expr) &&
             self.checked_dbg_call_site.insert(macro_call.span) &&
             // allows `dbg!` in test code if allow-dbg-in-test is set to true in clippy.toml
             !(self.allow_dbg_in_tests && is_in_test(cx.tcx, expr.hir_id))

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 !span.eq_ctxt(expr.span) || is_from_proc_macro(cx, expr) {
             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,12 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{snippet, walk_span_to_context};
+use clippy_utils::source::snippet;
 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;
+use rustc_span::{ExpnKind, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -41,26 +42,24 @@ declare_lint_pass!(RedundantAsyncBlock => [REDUNDANT_ASYNC_BLOCK]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let span = expr.span;
-        if !span.in_external_macro(cx.tcx.sess.source_map()) &&
+        if !expr.span.in_external_macro(cx.tcx.sess.source_map()) &&
             let Some(body_expr) = desugar_async_block(cx, expr) &&
-            let Some(expr) = desugar_await(peel_blocks(body_expr)) &&
+            let Some(inner_expr) = desugar_await(peel_blocks(body_expr)) &&
             // The await prefix must not come from a macro as its content could change in the future.
-            expr.span.eq_ctxt(body_expr.span) &&
+            !is_from_macro_within(inner_expr.span, body_expr.span) &&
             // The await prefix must implement Future, as implementing IntoFuture is not enough.
             let Some(future_trait) = cx.tcx.lang_items().future_trait() &&
-            implements_trait(cx, cx.typeck_results().expr_ty(expr), future_trait, &[]) &&
+            implements_trait(cx, cx.typeck_results().expr_ty(inner_expr), future_trait, &[]) &&
             // An async block does not have immediate side-effects from a `.await` point-of-view.
-            (!expr.can_have_side_effects() || desugar_async_block(cx, expr).is_some()) &&
-            let Some(shortened_span) = walk_span_to_context(expr.span, span.ctxt())
+            (!inner_expr.can_have_side_effects() || desugar_async_block(cx, inner_expr).is_some())
         {
             span_lint_and_sugg(
                 cx,
                 REDUNDANT_ASYNC_BLOCK,
-                span,
+                expr.span,
                 "this async expression only awaits a single future",
                 "you can reduce it to",
-                snippet(cx, shortened_span, "..").into_owned(),
+                snippet(cx, inner_expr.span, "..").into_owned(),
                 Applicability::MachineApplicable,
             );
         }
@@ -70,28 +69,41 @@ 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
     }
 }
+
+fn is_from_macro_within(mut span: Span, outer_span: Span) -> bool {
+    let outer_ctxt = outer_span.ctxt();
+    loop {
+        let ctxt = span.ctxt();
+        if ctxt.is_root() || ctxt == outer_ctxt {
+            break
+        }
+
+        let expn_data = ctxt.outer_expn_data();
+        match expn_data.kind {
+            ExpnKind::Macro { .. } => return true,
+            ExpnKind::Root
+            | ExpnKind::AstPass(_)
+            | ExpnKind::Desugaring(_) => {}
+        }
+        span = expn_data.call_site;
+    }
+
+    false
+}

src/tools/clippy/clippy_lints/src/redundant_closure_call.rs

@@ -1,14 +1,13 @@
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir};
-use clippy_utils::get_parent_expr;
+use clippy_utils::{get_async_closure_expr, get_parent_expr};
 use clippy_utils::sugg::Sugg;
 use hir::Param;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
-use rustc_hir::{ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, ExprKind, intravisit as hir_visit};
+use rustc_hir::{ClosureKind, CoroutineDesugaring, ExprKind, intravisit as hir_visit};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 use rustc_span::ExpnKind;
 use std::ops::ControlFlow;
@@ -52,21 +51,6 @@ impl<'tcx> Visitor<'tcx> for ReturnVisitor {
     }
 }
 
-/// Checks if the body is owned by an async closure.
-/// Returns true for `async || whatever_expression`, but false for `|| async { whatever_expression
-/// }`.
-fn is_async_closure(body: &hir::Body<'_>) -> bool {
-    if let ExprKind::Closure(innermost_closure_generated_by_desugar) = body.value.kind
-        // checks whether it is `async || whatever_expression`
-        && let ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, CoroutineSource::Closure))
-            = innermost_closure_generated_by_desugar.kind
-    {
-        true
-    } else {
-        false
-    }
-}
-
 /// Tries to find the innermost closure:
 /// ```rust,ignore
 /// (|| || || || 42)()()()()
@@ -82,7 +66,7 @@ fn find_innermost_closure<'tcx>(
 ) -> Option<(
     &'tcx hir::Expr<'tcx>,
     &'tcx hir::FnDecl<'tcx>,
-    ty::Asyncness,
+    ClosureKind,
     &'tcx [Param<'tcx>],
 )> {
     let mut data = None;
@@ -99,11 +83,7 @@ fn find_innermost_closure<'tcx>(
         data = Some((
             body.value,
             closure.fn_decl,
-            if is_async_closure(body) {
-                ty::Asyncness::Yes
-            } else {
-                ty::Asyncness::No
-            },
+            closure.kind,
             body.params,
         ));
         steps -= 1;
@@ -171,23 +151,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                         let mut hint =
                             Sugg::hir_with_context(cx, body, full_expr.span.ctxt(), "..", &mut applicability);
 
-                        if coroutine_kind.is_async()
-                            && let ExprKind::Closure(closure) = body.kind
+                        if let ClosureKind::CoroutineClosure(CoroutineDesugaring::Async) = coroutine_kind
+                            && let Some(body_expr) = get_async_closure_expr(cx.tcx, body)
                         {
                             // Like `async fn`, async closures are wrapped in an additional block
                             // to move all of the closure's arguments into the future.
 
-                            let async_closure_body = cx.tcx.hir_body(closure.body).value;
-                            let ExprKind::Block(block, _) = async_closure_body.kind else {
-                                return;
-                            };
-                            let Some(block_expr) = block.expr else {
-                                return;
-                            };
-                            let ExprKind::DropTemps(body_expr) = block_expr.kind else {
-                                return;
-                            };
-
                             // `async x` is a syntax error, so it becomes `async { x }`
                             if !matches!(body_expr.kind, ExprKind::Block(_, _)) {
                                 hint = hint.blockify();

src/tools/clippy/clippy_lints/src/unused_async.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
-use clippy_utils::is_def_id_trait_method;
+use clippy_utils::{get_async_closure_expr, is_def_id_trait_method};
 use clippy_utils::source::{HasSession, snippet_with_applicability, walk_span_to_context};
 use clippy_utils::usage::is_todo_unimplemented_stub;
 use rustc_errors::Applicability;
@@ -258,7 +258,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
 
             if !visitor.found_await
                 && let Some(builtin_crate) = clippy_utils::std_or_core(cx)
-                && let Some(inner) = unpack_async_fn_body(cx, body)
+                && let Some(inner) = get_async_closure_expr(cx.tcx, body.value)
                 // Find the tail expression contained in the async fn (if any),
                 // which will be wrapped in std::future::ready.
                 && let ExprKind::Block(block, _) = inner.kind
@@ -319,47 +319,6 @@ fn is_default_trait_impl(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
     )
 }
 
-/// Get the inner expression of the body of an async function.
-///
-/// If it is not an async function, returns `None`.
-///
-/// An async function like
-/// ```rs
-/// async fn get_random_number() -> i64 {
-///    do_something();
-///    4
-/// }
-/// ```
-/// (roughly) desugars to
-/// ```rs
-/// fn get_random_number() -> impl Future<Output = i64> {
-///     async move {
-///         do_something();
-///         4
-///     }
-/// }
-/// ```
-///
-/// We first get to the `async move {}` block,
-/// which is the one and only expression in the body of the function.
-/// This block is a coroutine wrapped in a closure.
-/// The expression in this block is contained in a terminating scope.
-///
-/// This function returns that expression in `Some(...)` if this body indeed is an async function.
-fn unpack_async_fn_body<'hir>(cx: &LateContext<'hir>, body: &Body<'hir>) -> Option<&'hir Expr<'hir>> {
-    if let ExprKind::Closure(closure) = body.value.kind
-        && let ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) = closure.kind
-        && let body = cx.tcx.hir_body(closure.body)
-        && let ExprKind::Block(block, _) = body.value.kind
-        && let Some(expr) = block.expr
-        && let ExprKind::DropTemps(inner) = expr.kind
-    {
-        Some(inner)
-    } else {
-        None
-    }
-}
-
 fn async_fn_contains_todo_unimplemented_macro<'hir>(cx: &LateContext<'hir>, body: &Body<'hir>) -> bool {
-    unpack_async_fn_body(cx, body).is_some_and(|inner| is_todo_unimplemented_stub(cx, inner))
+    get_async_closure_expr(cx.tcx, body.value).is_some_and(|inner| is_todo_unimplemented_stub(cx, inner))
 }

src/tools/clippy/clippy_lints/src/utils/author.rs

@@ -295,7 +295,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             && !id.is_local()
         {
             if let Some(lang) = self.cx.tcx.lang_items().from_def_id(id) {
-                chain!(self, "{path}.res(cx).is_lang_item(cx, LangItem::{}", lang.name());
+                chain!(self, "{path}.res(cx).is_lang_item(cx, LangItem::{})", lang.name());
             } else if let Some(name) = self.cx.tcx.get_diagnostic_name(id) {
                 chain!(self, "{path}.res(cx).is_diag_item(cx, sym::{name})");
             } else {