Add suggestions for expressions in patterns

Author: ShE3py

compiler/rustc_errors/src/lib.rs

@@ -535,6 +535,8 @@ pub enum StashKey {
     /// Query cycle detected, stashing in favor of a better error.
     Cycle,
     UndeterminedMacroResolution,
+    /// Used by `Parser::maybe_recover_trailing_expr`
+    ExprInPat,
 }
 
 fn default_track_diagnostic<R>(diag: DiagInner, f: &mut dyn FnMut(DiagInner) -> R) -> R {
@@ -837,6 +839,23 @@ impl<'a> DiagCtxtHandle<'a> {
         Some(Diag::new_diagnostic(self, diag))
     }
 
+    /// Steals a previously stashed error with the given `Span` and
+    /// [`StashKey`] as the key, and cancels it if found.
+    /// Panics if the found diagnostic's level isn't `Level::Error`.
+    pub fn steal_err(&self, span: Span, key: StashKey, _: ErrorGuaranteed) -> bool {
+        let key = (span.with_parent(None), key);
+        // FIXME(#120456) - is `swap_remove` correct?
+        self.inner
+            .borrow_mut()
+            .stashed_diagnostics
+            .swap_remove(&key)
+            .inspect(|(diag, guar)| {
+                assert_eq!(diag.level, Error);
+                assert!(guar.is_some())
+            })
+            .is_some()
+    }
+
     /// Steals a previously stashed error with the given `Span` and
     /// [`StashKey`] as the key, modifies it, and emits it. Returns `None` if
     /// no matching diagnostic is found. Panics if the found diagnostic's level
@@ -1281,6 +1300,17 @@ impl<'a> DiagCtxtHandle<'a> {
         self.create_err(err).emit()
     }
 
+    /// See [`DiagCtxtHandle::stash_diagnostic`] for details.
+    #[track_caller]
+    pub fn stash_err(
+        &'a self,
+        span: Span,
+        key: StashKey,
+        err: impl Diagnostic<'a>,
+    ) -> ErrorGuaranteed {
+        self.create_err(err).stash(span, key).unwrap()
+    }
+
     /// Ensures that an error is printed. See `Level::DelayedBug`.
     //
     // No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't

compiler/rustc_parse/messages.ftl

@@ -778,6 +778,20 @@ parse_unexpected_expr_in_pat =
 
     .label = arbitrary expressions are not allowed in patterns
 
+parse_unexpected_expr_in_pat_const_sugg = extract the expression into a `const` and refer to it
+
+parse_unexpected_expr_in_pat_create_guard_sugg = check the value in an arm guard
+
+parse_unexpected_expr_in_pat_inline_const_sugg = wrap the expression in a inline const (requires `{"#"}![feature(inline_const_pat)]`)
+
+parse_unexpected_expr_in_pat_remove_let_sugg =
+    remove the `let` if you meant to {$has_initializer ->
+        [true] do an assignment
+       *[false] evaluate an expression
+    }
+
+parse_unexpected_expr_in_pat_update_guard_sugg = check the value in the arm guard
+
 parse_unexpected_if_with_if = unexpected `if` in the condition expression
     .suggestion = remove the `if`
 

compiler/rustc_parse/src/errors.rs

@@ -2424,6 +2424,92 @@ pub(crate) struct UnexpectedExpressionInPattern {
     pub is_bound: bool,
 }
 
+#[derive(Subdiagnostic)]
+pub(crate) enum UnexpectedExpressionInPatternSugg {
+    #[multipart_suggestion(
+        parse_unexpected_expr_in_pat_remove_let_sugg,
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    RemoveLet {
+        /// The span of the `let` keyword.
+        #[suggestion_part(code = "")]
+        let_span: Span,
+        /// The span of the type annotation.
+        #[suggestion_part(code = "")]
+        ty_span: Option<Span>,
+        /// `true` iff the `let` statement has an initializer.
+        has_initializer: bool,
+    },
+
+    #[multipart_suggestion(
+        parse_unexpected_expr_in_pat_create_guard_sugg,
+        applicability = "maybe-incorrect"
+    )]
+    CreateGuard {
+        /// The span of the `PatKind:Err` to be transformed into a `PatKind::Ident`.
+        #[suggestion_part(code = "{ident}")]
+        ident_span: Span,
+        /// The end of the match arm's pattern.
+        #[suggestion_part(code = " if {ident} == {expr}")]
+        pat_hi: Span,
+        /// The suggested identifier.
+        ident: String,
+        /// `ident_span`'s snippet.
+        expr: String,
+    },
+
+    #[multipart_suggestion(
+        parse_unexpected_expr_in_pat_update_guard_sugg,
+        applicability = "maybe-incorrect"
+    )]
+    UpdateGuard {
+        /// The span of the `PatKind:Err` to be transformed into a `PatKind::Ident`.
+        #[suggestion_part(code = "{ident}")]
+        ident_span: Span,
+        /// The beginning of the match arm guard's expression.
+        #[suggestion_part(code = "(")]
+        guard_lo: Span,
+        /// The end of the match arm guard's expression.
+        #[suggestion_part(code = ") && {ident} == {expr}")]
+        guard_hi: Span,
+        /// The suggested identifier.
+        ident: String,
+        /// `ident_span`'s snippet.
+        expr: String,
+    },
+
+    #[multipart_suggestion(
+        parse_unexpected_expr_in_pat_const_sugg,
+        applicability = "has-placeholders"
+    )]
+    Const {
+        /// The beginning of statement's line.
+        #[suggestion_part(code = "{indentation}const {ident}: _ = {expr};\n")]
+        stmt_lo: Span,
+        /// The span of the `PatKind:Err` to be transformed into a `PatKind::Ident`.
+        #[suggestion_part(code = "{ident}")]
+        ident_span: Span,
+        /// The suggested identifier.
+        ident: String,
+        /// `ident_span`'s snippet.
+        expr: String,
+        /// The statement's block's indentation.
+        indentation: String,
+    },
+
+    #[multipart_suggestion(
+        parse_unexpected_expr_in_pat_inline_const_sugg,
+        applicability = "maybe-incorrect"
+    )]
+    InlineConst {
+        #[suggestion_part(code = "const {{ ")]
+        start_span: Span,
+        #[suggestion_part(code = " }}")]
+        end_span: Span,
+    },
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_unexpected_paren_in_range_pat)]
 pub(crate) struct UnexpectedParenInRangePat {

compiler/rustc_parse/src/parser/pat.rs

@@ -6,21 +6,22 @@ use crate::errors::{
     InclusiveRangeExtraEquals, InclusiveRangeMatchArrow, InclusiveRangeNoEnd, InvalidMutInPattern,
     PatternOnWrongSideOfAt, RemoveLet, RepeatedMutInPattern, SwitchRefBoxOrder,
     TopLevelOrPatternNotAllowed, TopLevelOrPatternNotAllowedSugg, TrailingVertNotAllowed,
-    UnexpectedExpressionInPattern, UnexpectedLifetimeInPattern, UnexpectedParenInRangePat,
-    UnexpectedParenInRangePatSugg, UnexpectedVertVertBeforeFunctionParam,
-    UnexpectedVertVertInPattern,
+    UnexpectedExpressionInPattern, UnexpectedExpressionInPatternSugg, UnexpectedLifetimeInPattern,
+    UnexpectedParenInRangePat, UnexpectedParenInRangePatSugg,
+    UnexpectedVertVertBeforeFunctionParam, UnexpectedVertVertInPattern,
 };
 use crate::parser::expr::{could_be_unclosed_char_literal, DestructuredFloat, LhsExpr};
 use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
 use rustc_ast::mut_visit::{noop_visit_pat, MutVisitor};
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, BinOpToken, Delimiter, Token};
+use rustc_ast::visit::{walk_arm, walk_pat, walk_pat_field, Visitor};
 use rustc_ast::{
-    self as ast, AttrVec, BindingMode, ByRef, Expr, ExprKind, MacCall, Mutability, Pat, PatField,
-    PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax,
+    self as ast, Arm, AttrVec, BindingMode, ByRef, Expr, ExprKind, LocalKind, MacCall, Mutability,
+    Pat, PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax, Stmt, StmtKind,
 };
 use rustc_ast_pretty::pprust;
-use rustc_errors::{Applicability, Diag, PResult};
+use rustc_errors::{Applicability, Diag, PResult, StashKey};
 use rustc_session::errors::ExprParenthesesNeeded;
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident};
@@ -431,12 +432,194 @@ impl<'a> Parser<'a> {
             || self.token.kind == token::CloseDelim(Delimiter::Parenthesis)
                 && self.look_ahead(1, Token::is_range_separator);
 
+        let span = expr.span;
+
         Some((
-            self.dcx().emit_err(UnexpectedExpressionInPattern { span: expr.span, is_bound }),
-            expr.span,
+            self.dcx().stash_err(
+                span,
+                StashKey::ExprInPat,
+                UnexpectedExpressionInPattern { span, is_bound },
+            ),
+            span,
         ))
     }
 
+    /// Called by [`Parser::parse_stmt_without_recovery`], used to add statement-aware subdiagnostics to the errors stashed
+    /// by [`Parser::maybe_recover_trailing_expr`].
+    pub(super) fn maybe_emit_stashed_expr_in_pats(&mut self, stmt: &Stmt) {
+        if self.dcx().has_errors().is_none() {
+            // No need to walk the statement if there's no stashed errors.
+            return;
+        }
+
+        struct PatVisitor<'a> {
+            /// `self`
+            parser: &'a Parser<'a>,
+            /// The freshly-parsed statement.
+            stmt: &'a Stmt,
+            /// The current match arm (for arm guard suggestions).
+            arm: Option<&'a Arm>,
+            /// The current struct field (for variable name suggestions).
+            field: Option<&'a PatField>,
+        }
+
+        impl<'a> PatVisitor<'a> {
+            /// Looks for stashed [`StashKey::ExprInPat`] errors in `stash_span`, and emit them with suggestions.
+            /// `stash_span` is contained in `expr_span`, the latter being larger in borrow patterns;
+            /// ```txt
+            /// &mut x.y
+            /// -----^^^ `stash_span`
+            /// |
+            /// `expr_span`
+            /// ```
+            fn emit_now(&self, stash_span: Span, expr_span: Span) {
+                self.parser.dcx().try_steal_modify_and_emit_err(
+                    stash_span,
+                    StashKey::ExprInPat,
+                    |err| {
+                        let sm = self.parser.psess.source_map();
+                        let stmt = self.stmt;
+                        let line_lo = sm.span_extend_to_line(stmt.span).shrink_to_lo();
+                        let indentation = sm.indentation_before(stmt.span).unwrap_or_default();
+                        let expr = self.parser.span_to_snippet(expr_span).unwrap();
+
+                        // Includes pre-pats (e.g. `&mut <err>`) in the diagnostic.
+                        err.span.replace(stash_span, expr_span);
+
+                        if let StmtKind::Let(local) = &stmt.kind {
+                            // help: remove the let
+
+                            match &local.kind {
+                                // help: remove the `let`
+                                LocalKind::Decl | LocalKind::Init(_) => {
+                                    err.subdiagnostic(
+                                        UnexpectedExpressionInPatternSugg::RemoveLet {
+                                            let_span: local
+                                                .span
+                                                .shrink_to_lo()
+                                                .until(local.pat.span),
+                                            ty_span: local
+                                                .colon_sp
+                                                .map(|sp| sp.to(local.ty.as_ref().unwrap().span)),
+                                            has_initializer: !matches!(local.kind, LocalKind::Decl),
+                                        },
+                                    );
+
+                                    // don't suggest `let const { pat } = expr;`
+                                    return;
+                                }
+
+                                LocalKind::InitElse(_, _) => {}
+                            }
+                        }
+
+                        // help: use an arm guard `if val == expr`
+                        if let Some(arm) = &self.arm {
+                            let (ident, ident_span) = match self.field {
+                                Some(field) => {
+                                    (field.ident.to_string(), field.ident.span.to(expr_span))
+                                }
+                                None => ("val".to_owned(), expr_span),
+                            };
+
+                            match &arm.guard {
+                                None => {
+                                    err.subdiagnostic(
+                                        UnexpectedExpressionInPatternSugg::CreateGuard {
+                                            ident_span,
+                                            pat_hi: arm.pat.span.shrink_to_hi(),
+                                            ident,
+                                            expr: expr.clone(),
+                                        },
+                                    );
+                                }
+                                Some(guard) => {
+                                    err.subdiagnostic(
+                                        UnexpectedExpressionInPatternSugg::UpdateGuard {
+                                            ident_span,
+                                            guard_lo: guard.span.shrink_to_lo(),
+                                            guard_hi: guard.span.shrink_to_hi(),
+                                            ident,
+                                            expr: expr.clone(),
+                                        },
+                                    );
+                                }
+                            }
+                        }
+
+                        // help: extract the expr into a `const VAL: _ = expr`
+                        let ident = match self.field {
+                            Some(field) => field.ident.as_str().to_uppercase(),
+                            None => "VAL".to_owned(),
+                        };
+                        err.subdiagnostic(UnexpectedExpressionInPatternSugg::Const {
+                            stmt_lo: line_lo,
+                            ident_span: expr_span,
+                            expr,
+                            ident,
+                            indentation,
+                        });
+
+                        // help: wrap the expr in a `const { expr }`
+                        // FIXME(inline_const_pat): once stabilized, remove this check and remove the `(requires #[feature(inline_const_pat)]` note from the message
+                        if self.parser.psess.unstable_features.is_nightly_build() {
+                            err.subdiagnostic(UnexpectedExpressionInPatternSugg::InlineConst {
+                                start_span: expr_span.shrink_to_lo(),
+                                end_span: expr_span.shrink_to_hi(),
+                            });
+                        }
+                    },
+                );
+            }
+        }
+
+        impl<'a> Visitor<'a> for PatVisitor<'a> {
+            fn visit_arm(&mut self, a: &'a Arm) -> Self::Result {
+                self.arm = Some(a);
+                walk_arm(self, a);
+                self.arm = None;
+            }
+
+            fn visit_pat_field(&mut self, fp: &'a PatField) -> Self::Result {
+                self.field = Some(fp);
+                walk_pat_field(self, fp);
+                self.field = None;
+            }
+
+            fn visit_pat(&mut self, p: &'a Pat) -> Self::Result {
+                match &p.kind {
+                    // Base expression
+                    PatKind::Err(_) => self.emit_now(p.span, p.span),
+
+                    // Sub-patterns
+                    // FIXME: this doesn't work with recursive subpats (`&mut &mut <err>`)
+                    PatKind::Box(subpat) | PatKind::Ref(subpat, _)
+                        if matches!(subpat.kind, PatKind::Err(_)) =>
+                    {
+                        self.emit_now(subpat.span, p.span)
+                    }
+
+                    // Sub-expressions
+                    PatKind::Range(start, end, _) => {
+                        if let Some(start) = start {
+                            self.emit_now(start.span, start.span);
+                        }
+
+                        if let Some(end) = end {
+                            self.emit_now(end.span, end.span);
+                        }
+                    }
+
+                    // Walk continuation
+                    _ => walk_pat(self, p),
+                }
+            }
+        }
+
+        // Starts the visit.
+        PatVisitor { parser: self, stmt, arm: None, field: None }.visit_stmt(stmt);
+    }
+
     /// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are
     /// allowed).
     fn parse_pat_with_range_pat(
@@ -586,7 +769,11 @@ impl<'a> Parser<'a> {
 
                     match self.parse_range_end() {
                         Some(form) => self.parse_pat_range_begin_with(begin, form)?,
-                        None => PatKind::Lit(begin),
+                        None => match &begin.kind {
+                            // Avoid `PatKind::Lit(ExprKind::Err)`
+                            ExprKind::Err(guar) => PatKind::Err(*guar),
+                            _ => PatKind::Lit(begin),
+                        },
                     }
                 }
                 Err(err) => return self.fatal_unexpected_non_pat(err, expected),
@@ -758,7 +945,25 @@ impl<'a> Parser<'a> {
 
         Ok(match self.maybe_recover_trailing_expr(open_paren.to(self.prev_token.span), false) {
             None => pat,
-            Some((guar, _)) => PatKind::Err(guar),
+            Some((guar, _)) => {
+                // We just recovered a bigger expression, so cancel its children
+                // (e.g. `(1 + 2) * 3`, cancel “`1 + 2` is not a pattern”).
+                match pat {
+                    PatKind::Paren(pat) => {
+                        self.dcx().steal_err(pat.span, StashKey::ExprInPat, guar);
+                    }
+
+                    PatKind::Tuple(fields) => {
+                        for pat in fields {
+                            self.dcx().steal_err(pat.span, StashKey::ExprInPat, guar);
+                        }
+                    }
+
+                    _ => unreachable!("{pat:?}"),
+                }
+
+                PatKind::Err(guar)
+            }
         })
     }
 

compiler/rustc_parse/src/parser/stmt.rs

@@ -30,6 +30,9 @@ use thin_vec::{thin_vec, ThinVec};
 impl<'a> Parser<'a> {
     /// Parses a statement. This stops just before trailing semicolons on everything but items.
     /// e.g., a `StmtKind::Semi` parses to a `StmtKind::Expr`, leaving the trailing `;` unconsumed.
+    ///
+    /// If `force_collect` is [`ForceCollect::Yes`], forces collection of tokens regardless of
+    /// whether or not we have attributes.
     // Public for rustfmt usage.
     pub(super) fn parse_stmt(&mut self, force_collect: ForceCollect) -> PResult<'a, Option<Stmt>> {
         Ok(self.parse_stmt_without_recovery(false, force_collect).unwrap_or_else(|e| {
@@ -66,7 +69,7 @@ impl<'a> Parser<'a> {
             });
         }
 
-        Ok(Some(if self.token.is_keyword(kw::Let) {
+        let stmt = if self.token.is_keyword(kw::Let) {
             self.parse_local_mk(lo, attrs, capture_semi, force_collect)?
         } else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
             self.recover_stmt_local_after_let(
@@ -140,7 +143,10 @@ impl<'a> Parser<'a> {
         } else {
             self.error_outer_attrs(attrs);
             return Ok(None);
-        }))
+        };
+
+        self.maybe_emit_stashed_expr_in_pats(&stmt);
+        Ok(Some(stmt))
     }
 
     fn parse_stmt_path_start(&mut self, lo: Span, attrs: AttrWrapper) -> PResult<'a, Stmt> {

tests/ui/half-open-range-patterns/range_pat_interactions1.stderr

@@ -3,6 +3,21 @@ error: expected a pattern range bound, found an expression
    |
 LL |             0..5+1 => errors_only.push(x),
    |                ^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |             0..val if val == 5+1 => errors_only.push(x),
+   |                ~~~ +++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +         const VAL: _ = 5+1;
+LL ~         match x as i32 {
+LL ~             0..VAL => errors_only.push(x),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |             0..const { 5+1 } => errors_only.push(x),
+   |                +++++++     +
 
 error[E0408]: variable `n` is not bound in all patterns
   --> $DIR/range_pat_interactions1.rs:10:25

tests/ui/half-open-range-patterns/range_pat_interactions2.stderr

@@ -1,9 +1,3 @@
-error: expected a pattern range bound, found an expression
-  --> $DIR/range_pat_interactions2.rs:10:18
-   |
-LL |             0..=(5+1) => errors_only.push(x),
-   |                  ^^^ arbitrary expressions are not allowed in patterns
-
 error: range pattern bounds cannot have parentheses
   --> $DIR/range_pat_interactions2.rs:10:17
    |
@@ -16,6 +10,27 @@ LL -             0..=(5+1) => errors_only.push(x),
 LL +             0..=5+1 => errors_only.push(x),
    |
 
+error: expected a pattern range bound, found an expression
+  --> $DIR/range_pat_interactions2.rs:10:18
+   |
+LL |             0..=(5+1) => errors_only.push(x),
+   |                  ^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |             0..=(val) if val == 5+1 => errors_only.push(x),
+   |                  ~~~  +++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +         const VAL: _ = 5+1;
+LL ~         match x as i32 {
+LL ~             0..=(VAL) => errors_only.push(x),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |             0..=(const { 5+1 }) => errors_only.push(x),
+   |                  +++++++     +
+
 error[E0658]: inline-const in pattern position is experimental
   --> $DIR/range_pat_interactions2.rs:15:20
    |

tests/ui/parser/bad-name.stderr

@@ -9,6 +9,12 @@ error: expected a pattern, found an expression
    |
 LL |   let x.y::<isize>.z foo;
    |       ^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to evaluate an expression
+   |
+LL -   let x.y::<isize>.z foo;
+LL +   x.y::<isize>.z foo;
+   |
 
 error: expected one of `(`, `.`, `::`, `:`, `;`, `=`, `?`, `|`, or an operator, found `foo`
   --> $DIR/bad-name.rs:2:22

tests/ui/parser/issues/issue-24197.stderr

@@ -3,6 +3,12 @@ error: expected a pattern, found an expression
    |
 LL |     let buf[0] = 0;
    |         ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to do an assignment
+   |
+LL -     let buf[0] = 0;
+LL +     buf[0] = 0;
+   |
 
 error: aborting due to 1 previous error
 

tests/ui/parser/issues/issue-24375.stderr

@@ -3,6 +3,21 @@ error: expected a pattern, found an expression
    |
 LL |         tmp[0] => {}
    |         ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         val if val == tmp[0] => {}
+   |         ~~~ ++++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = tmp[0];
+LL ~     match z {
+LL ~         VAL => {}
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { tmp[0] } => {}
+   |         +++++++        +
 
 error: aborting due to 1 previous error
 

tests/ui/parser/pat-lt-bracket-5.stderr

@@ -3,6 +3,12 @@ error: expected a pattern, found an expression
    |
 LL |     let v[0] = v[1];
    |         ^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to do an assignment
+   |
+LL -     let v[0] = v[1];
+LL +     v[0] = v[1];
+   |
 
 error[E0425]: cannot find value `v` in this scope
   --> $DIR/pat-lt-bracket-5.rs:2:16

tests/ui/parser/pat-lt-bracket-6.stderr

@@ -1,8 +1,14 @@
 error: expected a pattern, found an expression
-  --> $DIR/pat-lt-bracket-6.rs:5:15
+  --> $DIR/pat-lt-bracket-6.rs:5:14
    |
 LL |     let Test(&desc[..]) = x;
-   |               ^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |              ^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to do an assignment
+   |
+LL -     let Test(&desc[..]) = x;
+LL +     Test(&desc[..]) = x;
+   |
 
 error[E0308]: mismatched types
   --> $DIR/pat-lt-bracket-6.rs:10:30

tests/ui/parser/pat-ranges-3.stderr

@@ -3,12 +3,24 @@ error: expected a pattern range bound, found an expression
    |
 LL |     let 10 ..= 10 + 3 = 12;
    |                ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to do an assignment
+   |
+LL -     let 10 ..= 10 + 3 = 12;
+LL +     10 ..= 10 + 3 = 12;
+   |
 
 error: expected a pattern range bound, found an expression
   --> $DIR/pat-ranges-3.rs:7:9
    |
 LL |     let 10 - 3 ..= 10 = 8;
    |         ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to do an assignment
+   |
+LL -     let 10 - 3 ..= 10 = 8;
+LL +     10 - 3 ..= 10 = 8;
+   |
 
 error: aborting due to 2 previous errors
 

tests/ui/parser/recover/recover-pat-exprs.rs

@@ -40,9 +40,7 @@ fn type_cast() {
 fn operator() {
     match 0 {
         1 + 1 => (), //~ error: expected a pattern, found an expression
-        (1 + 2) * 3 => (),
-        //~^ error: expected a pattern, found an expression
-        //~| error: expected a pattern, found an expression
+        (1 + 2) * 3 => (), //~ error: expected a pattern, found an expression
     }
 }
 

tests/ui/parser/recover/recover-pat-exprs.stderr

@@ -3,36 +3,111 @@ error: expected a pattern, found an expression
    |
 LL |         Foo("hi".to_owned()) => true,
    |             ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         Foo(val) if val == "hi".to_owned() => true,
+   |             ~~~  +++++++++++++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = "hi".to_owned();
+LL ~     match foo {
+LL ~         Foo(VAL) => true,
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         Foo(const { "hi".to_owned() }) => true,
+   |             +++++++                 +
 
 error: expected a pattern, found an expression
   --> $DIR/recover-pat-issues.rs:14:20
    |
 LL |         Bar { baz: "hi".to_owned() } => true,
    |                    ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         Bar { baz } if baz == "hi".to_owned() => true,
+   |               ~~~   +++++++++++++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const BAZ: _ = "hi".to_owned();
+LL ~     match bar {
+LL ~         Bar { baz: BAZ } => true,
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         Bar { baz: const { "hi".to_owned() } } => true,
+   |                    +++++++                 +
 
 error: expected a pattern, found an expression
   --> $DIR/recover-pat-issues.rs:25:11
    |
 LL |         &["foo".to_string()] => {}
    |           ^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         &[val] if val == "foo".to_string() => {}
+   |           ~~~  +++++++++++++++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = "foo".to_string();
+LL ~     match foo.as_slice() {
+LL ~         &[VAL] => {}
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         &[const { "foo".to_string() }] => {}
+   |           +++++++                   +
 
 error: expected a pattern, found an expression
   --> $DIR/recover-pat-issues.rs:36:17
    |
 LL |     if let Some(MAGIC.0 as usize) = None::<usize> {}
    |                 ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = MAGIC.0 as usize;
+LL ~     if let Some(VAL) = None::<usize> {}
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     if let Some(const { MAGIC.0 as usize }) = None::<usize> {}
+   |                 +++++++                  +
 
 error: expected a pattern, found an expression
   --> $DIR/recover-pat-issues.rs:41:13
    |
 LL |     if let (-1.some(4)) = (0, Some(4)) {}
    |             ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = -1.some(4);
+LL ~     if let (VAL) = (0, Some(4)) {}
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     if let (const { -1.some(4) }) = (0, Some(4)) {}
+   |             +++++++            +
 
 error: expected a pattern, found an expression
   --> $DIR/recover-pat-issues.rs:44:13
    |
 LL |     if let (-1.Some(4)) = (0, Some(4)) {}
    |             ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = -1.Some(4);
+LL ~     if let (VAL) = (0, Some(4)) {}
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     if let (const { -1.Some(4) }) = (0, Some(4)) {}
+   |             +++++++            +
 
 error: aborting due to 6 previous errors
 

tests/ui/parser/recover/recover-pat-issues.stderr

@@ -3,6 +3,7 @@ fn main() {
 
     let x.expect("foo");
     //~^ error: expected a pattern, found an expression
+    //~| error: type annotations needed
 
     let x.unwrap(): u32;
     //~^ error: expected a pattern, found an expression

tests/ui/parser/recover/recover-pat-lets.rs

@@ -3,30 +3,80 @@ error: expected a pattern, found an expression
    |
 LL |     let x.expect("foo");
    |         ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to evaluate an expression
+   |
+LL -     let x.expect("foo");
+LL +     x.expect("foo");
+   |
 
 error: expected a pattern, found an expression
-  --> $DIR/recover-pat-lets.rs:7:9
+  --> $DIR/recover-pat-lets.rs:8:9
    |
 LL |     let x.unwrap(): u32;
    |         ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to evaluate an expression
+   |
+LL -     let x.unwrap(): u32;
+LL +     x.unwrap();
+   |
 
 error: expected a pattern, found an expression
-  --> $DIR/recover-pat-lets.rs:10:9
+  --> $DIR/recover-pat-lets.rs:11:9
    |
 LL |     let x[0] = 1;
    |         ^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to do an assignment
+   |
+LL -     let x[0] = 1;
+LL +     x[0] = 1;
+   |
 
 error: expected a pattern, found an expression
-  --> $DIR/recover-pat-lets.rs:13:14
+  --> $DIR/recover-pat-lets.rs:14:14
    |
 LL |     let Some(1 + 1) = x else {
    |              ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 1 + 1;
+LL ~     let Some(VAL) = x else {
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     let Some(const { 1 + 1 }) = x else {
+   |              +++++++       +
 
 error: expected a pattern, found an expression
-  --> $DIR/recover-pat-lets.rs:17:17
+  --> $DIR/recover-pat-lets.rs:18:17
    |
 LL |     if let Some(1 + 1) = x {
    |                 ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 1 + 1;
+LL ~     if let Some(VAL) = x {
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     if let Some(const { 1 + 1 }) = x {
+   |                 +++++++       +
+
+error[E0282]: type annotations needed
+  --> $DIR/recover-pat-lets.rs:4:9
+   |
+LL |     let x.expect("foo");
+   |         ^^^^^^^^^^^^^^^
+   |
+help: consider giving this pattern a type
+   |
+LL |     let x.expect("foo"): /* Type */;
+   |                        ++++++++++++
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
+For more information about this error, try `rustc --explain E0282`.

tests/ui/parser/recover/recover-pat-lets.stderr

@@ -46,12 +46,6 @@ LL -         (0)..=(-4) => (),
 LL +         (0)..=-4 => (),
    |
 
-error: expected a pattern range bound, found an expression
-  --> $DIR/recover-pat-ranges.rs:11:12
-   |
-LL |         ..=1 + 2 => (),
-   |            ^^^^^ arbitrary expressions are not allowed in patterns
-
 error: range pattern bounds cannot have parentheses
   --> $DIR/recover-pat-ranges.rs:13:9
    |
@@ -64,12 +58,6 @@ LL -         (4).. => (),
 LL +         4.. => (),
    |
 
-error: expected a pattern range bound, found an expression
-  --> $DIR/recover-pat-ranges.rs:15:10
-   |
-LL |         (-4 + 0).. => (),
-   |          ^^^^^^ arbitrary expressions are not allowed in patterns
-
 error: range pattern bounds cannot have parentheses
   --> $DIR/recover-pat-ranges.rs:15:9
    |
@@ -82,12 +70,6 @@ LL -         (-4 + 0).. => (),
 LL +         -4 + 0.. => (),
    |
 
-error: expected a pattern range bound, found an expression
-  --> $DIR/recover-pat-ranges.rs:18:10
-   |
-LL |         (1 + 4)...1 * 2 => (),
-   |          ^^^^^ arbitrary expressions are not allowed in patterns
-
 error: range pattern bounds cannot have parentheses
   --> $DIR/recover-pat-ranges.rs:18:9
    |
@@ -100,23 +82,149 @@ LL -         (1 + 4)...1 * 2 => (),
 LL +         1 + 4...1 * 2 => (),
    |
 
+error: expected a pattern range bound, found an expression
+  --> $DIR/recover-pat-ranges.rs:11:12
+   |
+LL |         ..=1 + 2 => (),
+   |            ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         ..=val if val == 1 + 2 => (),
+   |            ~~~ +++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 1 + 2;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         ..=VAL => (),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         ..=const { 1 + 2 } => (),
+   |            +++++++       +
+
+error: expected a pattern range bound, found an expression
+  --> $DIR/recover-pat-ranges.rs:15:10
+   |
+LL |         (-4 + 0).. => (),
+   |          ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         (val).. if val == -4 + 0 => (),
+   |          ~~~    ++++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = -4 + 0;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         (VAL).. => (),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         (const { -4 + 0 }).. => (),
+   |          +++++++        +
+
+error: expected a pattern range bound, found an expression
+  --> $DIR/recover-pat-ranges.rs:18:10
+   |
+LL |         (1 + 4)...1 * 2 => (),
+   |          ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         (val)...1 * 2 if val == 1 + 4 => (),
+   |          ~~~          +++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 1 + 4;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         (VAL)...1 * 2 => (),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         (const { 1 + 4 })...1 * 2 => (),
+   |          +++++++       +
+
 error: expected a pattern range bound, found an expression
   --> $DIR/recover-pat-ranges.rs:18:19
    |
 LL |         (1 + 4)...1 * 2 => (),
    |                   ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         (1 + 4)...val if val == 1 * 2 => (),
+   |                   ~~~ +++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 1 * 2;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         (1 + 4)...VAL => (),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         (1 + 4)...const { 1 * 2 } => (),
+   |                   +++++++       +
 
 error: expected a pattern range bound, found an expression
   --> $DIR/recover-pat-ranges.rs:24:9
    |
 LL |         0.x()..="y".z() => (),
    |         ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         val..="y".z() if val == 0.x() => (),
+   |         ~~~           +++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 0.x();
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         VAL..="y".z() => (),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { 0.x() }..="y".z() => (),
+   |         +++++++       +
 
 error: expected a pattern range bound, found an expression
   --> $DIR/recover-pat-ranges.rs:24:17
    |
 LL |         0.x()..="y".z() => (),
    |                 ^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         0.x()..=val if val == "y".z() => (),
+   |                 ~~~ +++++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = "y".z();
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         0.x()..=VAL => (),
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         0.x()..=const { "y".z() } => (),
+   |                 +++++++         +
 
 warning: `...` range patterns are deprecated
   --> $DIR/recover-pat-ranges.rs:18:16

tests/ui/parser/recover/recover-pat-ranges.stderr

@@ -54,12 +54,6 @@ error: expected one of `=>`, `if`, or `|`, found `(`
 LL |         ..(_) => ()
    |           ^ expected one of `=>`, `if`, or `|`
 
-error: expected a pattern range bound, found an expression
-  --> $DIR/recover-pat-wildcards.rs:55:14
-   |
-LL |         4..=(2 + _) => ()
-   |              ^^^^^ arbitrary expressions are not allowed in patterns
-
 error: range pattern bounds cannot have parentheses
   --> $DIR/recover-pat-wildcards.rs:55:13
    |
@@ -72,6 +66,27 @@ LL -         4..=(2 + _) => ()
 LL +         4..=2 + _ => ()
    |
 
+error: expected a pattern range bound, found an expression
+  --> $DIR/recover-pat-wildcards.rs:55:14
+   |
+LL |         4..=(2 + _) => ()
+   |              ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: check the value in an arm guard
+   |
+LL |         4..=(val) if val == 2 + _ => ()
+   |              ~~~  +++++++++++++++
+help: extract the expression into a `const` and refer to it
+   |
+LL +     const VAL: _ = 2 + _;
+LL ~     match 9 {
+LL ~         4..=(VAL) => ()
+   |
+help: wrap the expression in a inline const (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         4..=(const { 2 + _ }) => ()
+   |              +++++++       +
+
 error: aborting due to 11 previous errors
 
 For more information about this error, try `rustc --explain E0586`.

tests/ui/parser/recover/recover-pat-wildcards.stderr

@@ -3,6 +3,12 @@ error: expected a pattern, found an expression
    |
 LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
    |                               ^^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: remove the `let` if you meant to evaluate an expression
+   |
+LL -     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
+LL +     let str::<{fn str() { str::T>>::as_bytes; }}, T>::as_bytes;
+   |
 
 error[E0412]: cannot find type `T` in this scope
   --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:55