Auto merge of #120089 - matthiaskrgr:rollup-xyfqrb5, r=matthiaskrgr

Rollup of 8 pull requests

Successful merges:

 - #119172 (Detect `NulInCStr` error earlier.)
 - #119833 (Make tcx optional from StableMIR run macro and extend it to accept closures)
 - #119967 (Add `PatKind::Err` to AST/HIR)
 - #119978 (Move async closure parameters into the resultant closure's future eagerly)
 - #120021 (don't store const var origins for known vars)
 - #120038 (Don't create a separate "basename" when naming and opening a MIR dump file)
 - #120057 (Don't ICE when deducing future output if other errors already occurred)
 - #120073 (Remove spastorino from users_on_vacation)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

clippy_lints/src/async_yields_async.rs

@@ -45,50 +45,72 @@ declare_lint_pass!(AsyncYieldsAsync => [ASYNC_YIELDS_ASYNC]);
 
 impl<'tcx> LateLintPass<'tcx> for AsyncYieldsAsync {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        // For functions, with explicitly defined types, don't warn.
-        // XXXkhuey maybe we should?
-        if let ExprKind::Closure(Closure {
-            kind:
-                ClosureKind::Coroutine(CoroutineKind::Desugared(
-                    CoroutineDesugaring::Async,
-                    CoroutineSource::Block | CoroutineSource::Closure,
-                )),
+        let ExprKind::Closure(Closure {
+            kind: ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, kind)),
             body: body_id,
             ..
         }) = expr.kind
-        {
-            if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait() {
-                let typeck_results = cx.tcx.typeck_body(*body_id);
-                let body = cx.tcx.hir().body(*body_id);
-                let expr_ty = typeck_results.expr_ty(body.value);
+        else {
+            return;
+        };
 
-                if implements_trait(cx, expr_ty, future_trait_def_id, &[]) {
-                    let return_expr_span = match &body.value.kind {
-                        // XXXkhuey there has to be a better way.
-                        ExprKind::Block(block, _) => block.expr.map(|e| e.span),
-                        ExprKind::Path(QPath::Resolved(_, path)) => Some(path.span),
-                        _ => None,
-                    };
-                    if let Some(return_expr_span) = return_expr_span {
-                        span_lint_hir_and_then(
-                            cx,
-                            ASYNC_YIELDS_ASYNC,
-                            body.value.hir_id,
+        let body_expr = match kind {
+            CoroutineSource::Fn => {
+                // For functions, with explicitly defined types, don't warn.
+                // XXXkhuey maybe we should?
+                return;
+            },
+            CoroutineSource::Block => cx.tcx.hir().body(*body_id).value,
+            CoroutineSource::Closure => {
+                // 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(*body_id).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;
+                };
+                body_expr
+            },
+        };
+
+        let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait() else {
+            return;
+        };
+
+        let typeck_results = cx.tcx.typeck_body(*body_id);
+        let expr_ty = typeck_results.expr_ty(body_expr);
+
+        if implements_trait(cx, expr_ty, future_trait_def_id, &[]) {
+            let return_expr_span = match &body_expr.kind {
+                // XXXkhuey there has to be a better way.
+                ExprKind::Block(block, _) => block.expr.map(|e| e.span),
+                ExprKind::Path(QPath::Resolved(_, path)) => Some(path.span),
+                _ => None,
+            };
+            if let Some(return_expr_span) = return_expr_span {
+                span_lint_hir_and_then(
+                    cx,
+                    ASYNC_YIELDS_ASYNC,
+                    body_expr.hir_id,
+                    return_expr_span,
+                    "an async construct yields a type which is itself awaitable",
+                    |db| {
+                        db.span_label(body_expr.span, "outer async construct");
+                        db.span_label(return_expr_span, "awaitable value not awaited");
+                        db.span_suggestion(
                             return_expr_span,
-                            "an async construct yields a type which is itself awaitable",
-                            |db| {
-                                db.span_label(body.value.span, "outer async construct");
-                                db.span_label(return_expr_span, "awaitable value not awaited");
-                                db.span_suggestion(
-                                    return_expr_span,
-                                    "consider awaiting this value",
-                                    format!("{}.await", snippet(cx, return_expr_span, "..")),
-                                    Applicability::MaybeIncorrect,
-                                );
-                            },
+                            "consider awaiting this value",
+                            format!("{}.await", snippet(cx, return_expr_span, "..")),
+                            Applicability::MaybeIncorrect,
                         );
-                    }
-                }
+                    },
+                );
             }
         }
     }

clippy_lints/src/equatable_if_let.rs

@@ -51,7 +51,8 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
         | PatKind::Binding(..)
         | PatKind::Wild
         | PatKind::Never
-        | PatKind::Or(_) => false,
+        | PatKind::Or(_)
+        | PatKind::Err(_) => false,
         PatKind::Struct(_, a, etc) => !etc && a.iter().all(|x| unary_pattern(x.pat)),
         PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => etc.as_opt_usize().is_none() && array_rec(a),
         PatKind::Ref(x, _) | PatKind::Box(x) => unary_pattern(x),

clippy_lints/src/matches/match_same_arms.rs

@@ -11,7 +11,7 @@ use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdMapEntry, HirIdSet, P
 use rustc_lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::Symbol;
+use rustc_span::{ErrorGuaranteed, Symbol};
 
 use super::MATCH_SAME_ARMS;
 
@@ -167,6 +167,8 @@ enum NormalizedPat<'a> {
     /// contains everything afterwards. Note that either side, or both sides, may contain zero
     /// patterns.
     Slice(&'a [Self], Option<&'a [Self]>),
+    /// A placeholder for a pattern that wasn't well formed in some way.
+    Err(ErrorGuaranteed),
 }
 
 #[derive(Clone, Copy)]
@@ -329,6 +331,7 @@ impl<'a> NormalizedPat<'a> {
                 arena.alloc_from_iter(front.iter().map(|pat| Self::from_pat(cx, arena, pat))),
                 wild_pat.map(|_| &*arena.alloc_from_iter(back.iter().map(|pat| Self::from_pat(cx, arena, pat)))),
             ),
+            PatKind::Err(guar) => Self::Err(guar),
         }
     }
 

clippy_lints/src/redundant_closure_call.rs

@@ -5,7 +5,9 @@ use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
-use rustc_hir::{intravisit as hir_visit, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Node};
+use rustc_hir::{
+    intravisit as hir_visit, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, ExprKind, Node,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
@@ -166,10 +168,22 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                         if coroutine_kind.is_async()
                             && let hir::ExprKind::Closure(closure) = body.kind
                         {
-                            let async_closure_body = cx.tcx.hir().body(closure.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!(async_closure_body.value.kind, hir::ExprKind::Block(_, _)) {
+                            if !matches!(body_expr.kind, hir::ExprKind::Block(_, _)) {
                                 hint = hint.blockify();
                             }
 

clippy_lints/src/unnested_or_patterns.rs

@@ -226,7 +226,7 @@ fn transform_with_focus_on_idx(alternatives: &mut ThinVec<P<Pat>>, focus_idx: us
         // Therefore they are not some form of constructor `C`,
         // with which a pattern `C(p_0)` may be formed,
         // which we would want to join with other `C(p_j)`s.
-        Ident(.., None) | Lit(_) | Wild | Never | Path(..) | Range(..) | Rest | MacCall(_)
+        Ident(.., None) | Lit(_) | Wild | Err(_) | Never | Path(..) | Range(..) | Rest | MacCall(_)
         // Skip immutable refs, as grouping them saves few characters,
         // and almost always requires adding parens (increasing noisiness).
         // In the case of only two patterns, replacement adds net characters.

clippy_lints/src/utils/author.rs

@@ -710,6 +710,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 self.slice(start, |pat| self.pat(pat));
                 self.slice(end, |pat| self.pat(pat));
             },
+            PatKind::Err(_) => kind!("Err"),
         }
     }
 

clippy_utils/src/hir_utils.rs

@@ -1007,7 +1007,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 }
                 e.hash(&mut self.s);
             },
-            PatKind::Never | PatKind::Wild => {},
+            PatKind::Never | PatKind::Wild | PatKind::Err(_) => {},
         }
     }
 

clippy_utils/src/lib.rs

@@ -1733,6 +1733,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
                 },
             }
         },
+        PatKind::Err(_) => true,
     }
 }
 

tests/ui/author/blocks.stdout

@@ -48,7 +48,11 @@ if let ExprKind::Closure { capture_clause: CaptureBy::Value { .. }, fn_decl: fn_
     && expr2 = &cx.tcx.hir().body(body_id1).value
     && let ExprKind::Block(block, None) = expr2.kind
     && block.stmts.is_empty()
-    && block.expr.is_none()
+    && let Some(trailing_expr) = block.expr
+    && let ExprKind::DropTemps(expr3) = trailing_expr.kind
+    && let ExprKind::Block(block1, None) = expr3.kind
+    && block1.stmts.is_empty()
+    && block1.expr.is_none()
 {
     // report your lint here
 }