Add expr in pat recovery suggestions

Author: ShE3py

compiler/rustc_parse/messages.ftl

@@ -780,6 +780,10 @@ parse_unexpected_expr_in_pat =
        *[false] arbitrary expressions
     } are not allowed in patterns
 
+    .help = extract the expression into a `const` and refer to it
+
+parse_unexpected_expr_in_pat_const_pat_sugg = wrap the expression in a inline const (requires `{"#"}![feature(inline_const)]`)
+
 parse_unexpected_if_with_if = unexpected `if` in the condition expression
     .suggestion = remove the `if`
 

compiler/rustc_parse/src/errors.rs

@@ -2424,6 +2424,7 @@ pub(crate) struct ExpectedCommaAfterPatternField {
 
 #[derive(Diagnostic)]
 #[diag(parse_unexpected_expr_in_pat)]
+#[help]
 pub(crate) struct UnexpectedExpressionInPattern {
     #[primary_span]
     #[label]
@@ -2434,6 +2435,18 @@ pub(crate) struct UnexpectedExpressionInPattern {
     pub is_method_call: bool,
 }
 
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    parse_unexpected_expr_in_pat_const_pat_sugg,
+    applicability = "machine-applicable"
+)]
+pub(crate) struct UnexpectedExpressionInPatternConstPatSugg {
+    #[suggestion_part(code = "const {{ ")]
+    pub start_span: Span,
+    #[suggestion_part(code = " }}")]
+    pub end_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_unexpected_paren_in_range_pat)]
 pub(crate) struct UnexpectedParenInRangePat {

compiler/rustc_parse/src/parser/pat.rs

@@ -6,9 +6,9 @@ use crate::errors::{
     InclusiveRangeExtraEquals, InclusiveRangeMatchArrow, InclusiveRangeNoEnd, InvalidMutInPattern,
     PatternOnWrongSideOfAt, RemoveLet, RepeatedMutInPattern, SwitchRefBoxOrder,
     TopLevelOrPatternNotAllowed, TopLevelOrPatternNotAllowedSugg, TrailingVertNotAllowed,
-    UnexpectedExpressionInPattern, UnexpectedLifetimeInPattern, UnexpectedParenInRangePat,
-    UnexpectedParenInRangePatSugg, UnexpectedVertVertBeforeFunctionParam,
-    UnexpectedVertVertInPattern,
+    UnexpectedExpressionInPattern, UnexpectedExpressionInPatternConstPatSugg,
+    UnexpectedLifetimeInPattern, UnexpectedParenInRangePat, UnexpectedParenInRangePatSugg,
+    UnexpectedVertVertBeforeFunctionParam, UnexpectedVertVertInPattern,
 };
 use crate::parser::expr::{could_be_unclosed_char_literal, DestructuredFloat};
 use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
@@ -431,14 +431,22 @@ impl<'a> Parser<'a> {
 
                 let span = expr.span;
 
-                return Some((
-                    self.dcx().stash_err(
-                        span,
-                        StashKey::ExprInPat,
-                        UnexpectedExpressionInPattern { span, is_bound, is_method_call },
-                    ),
+                let mut diag = self.dcx().create_err(UnexpectedExpressionInPattern {
                     span,
-                ));
+                    is_bound,
+                    is_method_call,
+                });
+                if self.psess.unstable_features.is_nightly_build() {
+                    diag.subdiagnostic(
+                        &self.dcx(),
+                        UnexpectedExpressionInPatternConstPatSugg {
+                            start_span: span.shrink_to_lo(),
+                            end_span: span.shrink_to_hi(),
+                        },
+                    );
+                }
+
+                return Some((diag.stash(span, StashKey::ExprInPat).unwrap(), span));
             }
         }
 

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

@@ -98,6 +98,12 @@ 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: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |             0..const { 5+1 } => errors_only.push(x),
+   |                +++++++     +
 
 error: aborting due to 10 previous errors
 

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

@@ -69,6 +69,12 @@ 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: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |             0..=(const { 5+1 }) => errors_only.push(x),
+   |                  +++++++     +
 
 error: aborting due to 7 previous errors
 

tests/ui/parser/bad-name.stderr

@@ -15,6 +15,12 @@ error: expected a pattern, found an expression
    |
 LL |   let x.y::<isize>.z foo;
    |       ^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+   = help: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |   let const { x.y::<isize>.z } foo;
+   |       +++++++                +
 
 error: aborting due to 3 previous errors
 

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: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |     let const { buf[0] } = 0;
+   |         +++++++        +
 
 error: aborting due to 1 previous error
 

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

@@ -3,6 +3,12 @@ error: expected a pattern, found an expression
    |
 LL |         tmp[0] => {}
    |         ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+   = help: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |         const { tmp[0] } => {}
+   |         +++++++        +
 
 error: aborting due to 1 previous error
 

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

@@ -9,6 +9,12 @@ error: expected a pattern, found an expression
    |
 LL |     let v[0] = v[1];
    |         ^^^^ arbitrary expressions are not allowed in patterns
+   |
+   = help: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |     let const { v[0] } = v[1];
+   |         +++++++      +
 
 error: aborting due to 2 previous errors
 

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

@@ -23,6 +23,12 @@ error: expected a pattern, found an expression
    |
 LL |     let Test(&desc[..]) = x;
    |               ^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+   = help: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |     let Test(&const { desc[..] }) = x;
+   |               +++++++          +
 
 error: aborting due to 3 previous errors
 

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: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |     let 10 ..= const { 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: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |     let const { 10 - 3 } ..= 10 = 8;
+   |         +++++++        +
 
 error: aborting due to 2 previous errors
 

tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr

@@ -29,6 +29,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: extract the expression into a `const` and refer to it
+help: wrap the expression in a inline const (requires `#![feature(inline_const)]`)
+   |
+LL |     let str::<{fn str() { let const { str::T>>::as_bytes }; }}, T>::as_bytes;
+   |                               +++++++                    +
 
 error: aborting due to 4 previous errors