Add match arm suggestions

Author: ShE3py

compiler/rustc_parse/messages.ftl

@@ -780,10 +780,14 @@ parse_unexpected_expr_in_pat =
 
     .label = arbitrary expressions are not allowed in patterns
 
-parse_unexpected_expr_in_pat_const_pat_sugg = wrap the expression in a inline const (requires `{"#"}![feature(inline_const)]`)
-
 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)]`)
+
+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

@@ -2442,28 +2442,73 @@ pub(crate) struct UnexpectedExpressionInPattern {
 }
 
 #[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    parse_unexpected_expr_in_pat_const_pat_sugg,
-    applicability = "maybe-incorrect"
-)]
-pub(crate) struct UnexpectedExpressionInPatternConstPatSugg {
-    #[suggestion_part(code = "const {{ ")]
-    pub start_span: Span,
-    #[suggestion_part(code = " }}")]
-    pub end_span: Span,
+pub(crate) enum UnexpectedExpressionInPatternArmSugg {
+    #[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,
+    },
 }
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(parse_unexpected_expr_in_pat_const_sugg, applicability = "has-placeholders")]
 pub(crate) struct UnexpectedExpressionInPatternConstSugg {
-    #[suggestion_part(code = "{indentation}const VAL: _ = {expr};\n")]
-    pub const_span: Span,
-    #[suggestion_part(code = "VAL")]
-    pub pat_span: Span,
+    /// The beginning of statement's line.
+    #[suggestion_part(code = "{indentation}const {ident}: _ = {expr};\n")]
+    pub stmt_lo: Span,
+    /// The span of the `PatKind:Err` to be transformed into a `PatKind::Ident`.
+    #[suggestion_part(code = "{ident}")]
+    pub ident_span: Span,
+    /// The suggested identifier.
+    pub ident: String,
+    /// `ident_span`'s snippet.
     pub expr: String,
+    /// The statement's block's indentation.
     pub indentation: String,
 }
 
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    parse_unexpected_expr_in_pat_inline_const_sugg,
+    applicability = "maybe-incorrect"
+)]
+pub(crate) struct UnexpectedExpressionInPatternInlineConstSugg {
+    #[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/item.rs

@@ -4,7 +4,10 @@ use super::{
     AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, Recovered, Trailing,
     TrailingToken,
 };
-use crate::errors::{self, MacroExpandsToAdtField, UnexpectedExpressionInPatternConstSugg};
+use crate::errors::{
+    self, MacroExpandsToAdtField, UnexpectedExpressionInPatternArmSugg,
+    UnexpectedExpressionInPatternConstSugg, UnexpectedExpressionInPatternInlineConstSugg,
+};
 use crate::fluent_generated as fluent;
 use crate::maybe_whole;
 use ast::token::IdentIsRaw;
@@ -13,7 +16,7 @@ use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter, TokenKind};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
-use rustc_ast::visit::{walk_pat, walk_stmt, Visitor};
+use rustc_ast::visit::{walk_arm, walk_pat, walk_pat_field, walk_stmt, Visitor};
 use rustc_ast::{self as ast};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{codes::*, struct_span_code_err, Applicability, PResult, StashKey};
@@ -2365,9 +2368,19 @@ impl<'a> Parser<'a> {
         };
 
         if let Some(body) = &body {
+            // WIP: once a fn body has been parsed, we walk through all its patterns,
+            // and emit now what errors `maybe_recover_trailing_expr()` stashed,
+            // with suggestions depending on which statement the pattern is.
+
             struct PatVisitor<'a> {
+                /// `self`
                 parser: &'a Parser<'a>,
+                /// The current statement.
                 stmt: Option<&'a Stmt>,
+                /// The current match arm.
+                arm: Option<&'a Arm>,
+                /// The current struct field.
+                field: Option<&'a PatField>,
             }
 
             impl<'a> Visitor<'a> for PatVisitor<'a> {
@@ -2377,36 +2390,140 @@ impl<'a> Parser<'a> {
                     walk_stmt(self, s)
                 }
 
-                fn visit_pat(&mut self, pat: &'a Pat) -> Self::Result {
-                    if matches!(pat.kind, PatKind::Err(_)) {
-                        let sm = self.parser.psess.source_map();
-
-                        self.parser.dcx().try_steal_modify_and_emit_err(
-                            pat.span,
-                            StashKey::ExprInPat,
-                            |err| {
-                                err.subdiagnostic(
-                                    &self.parser.dcx(),
-                                    UnexpectedExpressionInPatternConstSugg {
-                                        const_span: sm
-                                            .span_extend_to_line(self.stmt.unwrap().span)
-                                            .shrink_to_lo(),
-                                        pat_span: pat.span,
-                                        expr: self.parser.span_to_snippet(pat.span).unwrap(),
-                                        indentation: sm
-                                            .indentation_before(self.stmt.unwrap().span)
-                                            .unwrap_or_default(),
-                                    },
-                                );
-                            },
-                        );
-                    }
+                fn visit_arm(&mut self, a: &'a Arm) -> Self::Result {
+                    self.arm = Some(a);
+                    walk_arm(self, a);
+                    self.arm = None;
+                }
 
-                    walk_pat(self, pat)
+                fn visit_pat_field(&mut self, fp: &'a PatField) -> Self::Result {
+                    self.field = Some(fp);
+                    walk_pat_field(self, fp);
+                    self.field = None;
                 }
-            }
 
-            PatVisitor { parser: self, stmt: None }.visit_block(body);
+                fn visit_pat(&mut self, p: &'a Pat) -> Self::Result {
+                    // Looks for stashed `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`
+                    // ```
+                    let emit_now = |that: &Self,
+                                    stash_span: Span,
+                                    expr_span: Span|
+                     -> Self::Result {
+                        that.parser.dcx().try_steal_modify_and_emit_err(
+                                stash_span,
+                                StashKey::ExprInPat,
+                                |err| {
+                                    let sm = that.parser.psess.source_map();
+                                    let stmt = that.stmt.unwrap();
+                                    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 = that.parser.span_to_snippet(expr_span).unwrap();
+
+                                    err.span.replace(stash_span, expr_span);
+
+                                    if let StmtKind::Let(local) = &stmt.kind {
+                                        // If we have an `ExprInPat`, the user tried to assign a value to another value,
+                                        // which doesn't makes much sense.
+                                        match &local.kind {
+                                            LocalKind::Decl => {}
+                                            LocalKind::Init(_) => {}
+                                            LocalKind::InitElse(_, _) => {}
+                                        }
+                                    }
+                                    else {
+                                        // 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(&that.parser.dcx(), UnexpectedExpressionInPatternArmSugg::CreateGuard {
+                                                        ident_span,
+                                                        pat_hi: arm.pat.span.shrink_to_hi(),
+                                                        ident,
+                                                        expr: expr.clone(),
+                                                    });
+                                                }
+                                                Some(guard) => {
+                                                    err.subdiagnostic(&that.parser.dcx(), UnexpectedExpressionInPatternArmSugg::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(
+                                            &that.parser.dcx(),
+                                            UnexpectedExpressionInPatternConstSugg {
+                                                stmt_lo: line_lo,
+                                                ident_span: expr_span,
+                                                expr,
+                                                ident,
+                                                indentation,
+                                            },
+                                        );
+
+                                        // help: wrap the expr in a `const { expr }`
+                                        // FIXME(inline_const): once stabilized, remove this check and remove the `(requires #[feature(inline_const])` note from the message
+                                        if that.parser.psess.unstable_features.is_nightly_build() {
+                                            err.subdiagnostic(
+                                                &that.parser.dcx(),
+                                                UnexpectedExpressionInPatternInlineConstSugg {
+                                                    start_span: expr_span.shrink_to_lo(),
+                                                    end_span: expr_span.shrink_to_hi(),
+                                                },
+                                            );
+                                        }
+                                    }
+                                },
+                            );
+                    }; // end of `emit_now` closure, we're back in `visit_pat`
+
+                    match &p.kind {
+                        // Base expression
+                        PatKind::Err(_) => emit_now(self, p.span, p.span),
+                        // Sub-patterns
+                        PatKind::Box(subpat) | PatKind::Ref(subpat, _)
+                            if matches!(subpat.kind, PatKind::Err(_)) =>
+                        {
+                            emit_now(self, subpat.span, p.span)
+                        }
+                        // Sub-expressions
+                        PatKind::Range(start, end, _) => {
+                            if let Some(start) = start {
+                                emit_now(self, start.span, start.span);
+                            }
+
+                            if let Some(end) = end {
+                                emit_now(self, end.span, end.span);
+                            }
+                        }
+                        // Walk continuation
+                        _ => walk_pat(self, p),
+                    }
+                }
+            } // end of `PatVisitor` impl, we're back in `parse_fn_body`
+
+            PatVisitor { parser: self, stmt: None, arm: None, field: None }.visit_block(body);
         }
 
         attrs.extend(inner_attrs);

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, UnexpectedExpressionInPatternConstPatSugg,
-    UnexpectedLifetimeInPattern, UnexpectedParenInRangePat, UnexpectedParenInRangePatSugg,
-    UnexpectedVertVertBeforeFunctionParam, UnexpectedVertVertInPattern,
+    UnexpectedExpressionInPattern, 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};
@@ -424,19 +424,7 @@ impl<'a> Parser<'a> {
 
                 let span = expr.span;
 
-                let mut err =
-                    self.dcx().create_err(UnexpectedExpressionInPattern { span, is_bound });
-
-                // FIXME(inline_const): once stabilized, remove this check and remove the `(requires #[feature(inline_const])` note from the message
-                if self.psess.unstable_features.is_nightly_build() {
-                    err.subdiagnostic(
-                        &self.dcx(),
-                        UnexpectedExpressionInPatternConstPatSugg {
-                            start_span: span.shrink_to_lo(),
-                            end_span: span.shrink_to_hi(),
-                        },
-                    );
-                }
+                let err = self.dcx().create_err(UnexpectedExpressionInPattern { span, is_bound });
 
                 return Some((err.stash(span, StashKey::ExprInPat).unwrap(), span));
             }
@@ -587,19 +575,20 @@ impl<'a> Parser<'a> {
         } else {
             // Try to parse everything else as literal with optional minus
             match self.parse_literal_maybe_minus() {
-                Ok(mut begin) => {
-                    let guar =
-                        self.maybe_recover_trailing_expr(begin.span, false).map(|(guar, sp)| {
-                            begin = self.mk_expr_err(sp, guar);
-                            guar
-                        });
-
-                    let pat = match self.parse_range_end() {
-                        Some(form) => self.parse_pat_range_begin_with(begin, form)?,
-                        None => PatKind::Lit(begin),
-                    };
+                Ok(begin) => {
+                    let begin = self
+                        .maybe_recover_trailing_expr(begin.span, false)
+                        .map(|(guar, sp)| self.mk_expr_err(sp, guar))
+                        .unwrap_or(begin);
 
-                    if let Some(guar) = guar { PatKind::Err(guar) } else { pat }
+                    match self.parse_range_end() {
+                        Some(form) => self.parse_pat_range_begin_with(begin, form)?,
+                        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),
             }