From b317f9fb7f934e87e86bcbcfae889ee326051992 Mon Sep 17 00:00:00 2001
From: Lieselotte <52315535+she3py@users.noreply.github.com>
Date: Thu, 4 Jul 2024 14:10:17 +0200
Subject: [PATCH] Recover more expressions in patterns

---
 compiler/rustc_parse/messages.ftl             |  10 +-
 compiler/rustc_parse/src/errors.rs            |   2 -
 compiler/rustc_parse/src/parser/expr.rs       |  16 +-
 compiler/rustc_parse/src/parser/pat.rs        | 132 ++++++-----
 tests/ui/parser/bad-name.rs                   |   5 +-
 tests/ui/parser/bad-name.stderr               |  20 +-
 tests/ui/parser/pat-recover-exprs.rs          |  28 ---
 tests/ui/parser/pat-recover-exprs.stderr      |  76 -------
 tests/ui/parser/pat-recover-methodcalls.rs    |  37 ----
 .../ui/parser/pat-recover-methodcalls.stderr  |  35 ---
 tests/ui/parser/recover/recover-pat-exprs.rs  |  81 +++++++
 .../parser/recover/recover-pat-exprs.stderr   | 208 ++++++++++++++++++
 tests/ui/parser/recover/recover-pat-issues.rs |  46 ++++
 .../parser/recover/recover-pat-issues.stderr  |  38 ++++
 tests/ui/parser/recover/recover-pat-lets.rs   |  20 ++
 .../ui/parser/recover/recover-pat-lets.stderr |  32 +++
 .../recover-pat-ranges.rs}                    |   4 +-
 .../recover-pat-ranges.stderr}                |  36 +--
 .../recover-pat-wildcards.rs}                 |   0
 .../recover-pat-wildcards.stderr}             |  22 +-
 20 files changed, 561 insertions(+), 287 deletions(-)
 delete mode 100644 tests/ui/parser/pat-recover-exprs.rs
 delete mode 100644 tests/ui/parser/pat-recover-exprs.stderr
 delete mode 100644 tests/ui/parser/pat-recover-methodcalls.rs
 delete mode 100644 tests/ui/parser/pat-recover-methodcalls.stderr
 create mode 100644 tests/ui/parser/recover/recover-pat-exprs.rs
 create mode 100644 tests/ui/parser/recover/recover-pat-exprs.stderr
 create mode 100644 tests/ui/parser/recover/recover-pat-issues.rs
 create mode 100644 tests/ui/parser/recover/recover-pat-issues.stderr
 create mode 100644 tests/ui/parser/recover/recover-pat-lets.rs
 create mode 100644 tests/ui/parser/recover/recover-pat-lets.stderr
 rename tests/ui/parser/{pat-recover-ranges.rs => recover/recover-pat-ranges.rs} (89%)
 rename tests/ui/parser/{pat-recover-ranges.stderr => recover/recover-pat-ranges.stderr} (77%)
 rename tests/ui/parser/{pat-recover-wildcards.rs => recover/recover-pat-wildcards.rs} (100%)
 rename tests/ui/parser/{pat-recover-wildcards.stderr => recover/recover-pat-wildcards.stderr} (79%)

diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index e4c75ac11454a..9afbdba66240e 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -774,15 +774,9 @@ parse_unexpected_expr_in_pat =
     expected {$is_bound ->
         [true] a pattern range bound
        *[false] a pattern
-    }, found {$is_method_call ->
-        [true] a method call
-       *[false] an expression
-    }
+    }, found an expression
 
-    .label = {$is_method_call ->
-        [true] method calls
-       *[false] arbitrary expressions
-    } are not allowed in patterns
+    .label = arbitrary expressions are not allowed in patterns
 
 parse_unexpected_if_with_if = unexpected `if` in the condition expression
     .suggestion = remove the `if`
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 6894f470d88fd..eee991c2b3130 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -2422,8 +2422,6 @@ pub(crate) struct UnexpectedExpressionInPattern {
     pub span: Span,
     /// Was a `RangePatternBound` expected?
     pub is_bound: bool,
-    /// Was the unexpected expression a `MethodCallExpression`?
-    pub is_method_call: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 5402d5b0b3d9b..220f63938be83 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -41,14 +41,14 @@ use tracing::instrument;
 
 #[derive(Debug)]
 pub(super) enum LhsExpr {
-    // Already parsed just the outer attributes.
+    /// Already parsed just the outer attributes.
     Unparsed { attrs: AttrWrapper },
-    // Already parsed the expression.
+    /// Already parsed the expression.
     Parsed { expr: P<Expr>, starts_statement: bool },
 }
 
 #[derive(Debug)]
-enum DestructuredFloat {
+pub(super) enum DestructuredFloat {
     /// 1e2
     Single(Symbol, Span),
     /// 1.
@@ -1036,15 +1036,17 @@ impl<'a> Parser<'a> {
         self.dcx().emit_err(errors::UnexpectedTokenAfterDot { span, actual })
     }
 
-    // We need an identifier or integer, but the next token is a float.
-    // Break the float into components to extract the identifier or integer.
+    /// We need an identifier or integer, but the next token is a float.
+    /// Break the float into components to extract the identifier or integer.
+    ///
+    /// See also [`TokenKind::break_two_token_op`] which does similar splitting of `>>` into `>`.
+    //
     // FIXME: With current `TokenCursor` it's hard to break tokens into more than 2
     // parts unless those parts are processed immediately. `TokenCursor` should either
     // support pushing "future tokens" (would be also helpful to `break_and_eat`), or
     // we should break everything including floats into more basic proc-macro style
     // tokens in the lexer (probably preferable).
-    // See also `TokenKind::break_two_token_op` which does similar splitting of `>>` into `>`.
-    fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat {
+    pub(super) fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat {
         #[derive(Debug)]
         enum FloatComponent {
             IdentLike(String),
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 6f2b717715945..040e5b54ad459 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -10,7 +10,7 @@ use crate::errors::{
     UnexpectedParenInRangePatSugg, UnexpectedVertVertBeforeFunctionParam,
     UnexpectedVertVertInPattern,
 };
-use crate::parser::expr::{could_be_unclosed_char_literal, LhsExpr};
+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;
@@ -337,7 +337,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Ensures that the last parsed pattern (or pattern range bound) is not followed by a method call or an operator.
+    /// Ensures that the last parsed pattern (or pattern range bound) is not followed by an expression.
     ///
     /// `is_end_bound` indicates whether the last parsed thing was the end bound of a range pattern (see [`parse_pat_range_end`](Self::parse_pat_range_end))
     /// in order to say "expected a pattern range bound" instead of "expected a pattern";
@@ -345,38 +345,53 @@ impl<'a> Parser<'a> {
     /// 0..=1 + 2
     ///     ^^^^^
     /// ```
-    /// Only the end bound is spanned, and this function have no idea if there were a `..=` before `pat_span`, hence the parameter.
+    /// Only the end bound is spanned in this case, and this function have no idea if there were a `..=` before `pat_span`, hence the parameter.
+    ///
+    /// This function returns `Some` if a trailing expression was recovered, and said expression's span.
     #[must_use = "the pattern must be discarded as `PatKind::Err` if this function returns Some"]
     fn maybe_recover_trailing_expr(
         &mut self,
         pat_span: Span,
         is_end_bound: bool,
-    ) -> Option<ErrorGuaranteed> {
+    ) -> Option<(ErrorGuaranteed, Span)> {
         if self.prev_token.is_keyword(kw::Underscore) || !self.may_recover() {
             // Don't recover anything after an `_` or if recovery is disabled.
             return None;
         }
 
-        // Check for `.hello()`, but allow `.Hello()` to be recovered as `, Hello()` in `parse_seq_to_before_tokens()`.
-        let has_trailing_method = self.check_noexpect(&token::Dot)
+        // Returns `true` iff `token` is a `x.y` float.
+        let is_two_tuple_indexes = |that: &Self, token: &Token| -> bool {
+            use token::{Lit, LitKind};
+
+            let token::Literal(Lit { kind: LitKind::Float, symbol, suffix: None }) = token.kind
+            else {
+                return false;
+            };
+
+            matches!(that.break_up_float(symbol, token.span), DestructuredFloat::MiddleDot(..))
+        };
+
+        // Check for `.hello` or `.0`.
+        let has_dot_expr = self.check_noexpect(&token::Dot) // `.`
             && self.look_ahead(1, |tok| {
-                tok.ident()
-                    .and_then(|(ident, _)| ident.name.as_str().chars().next())
-                    .is_some_and(char::is_lowercase)
-            })
-            && self.look_ahead(2, |tok| tok.kind == token::OpenDelim(Delimiter::Parenthesis));
+                tok.is_ident() // `hello`
+                || tok.is_integer_lit() // `0`
+                || is_two_tuple_indexes(&self, &tok) // `0.0`
+            });
 
         // Check for operators.
         // `|` is excluded as it is used in pattern alternatives and lambdas,
         // `?` is included for error propagation,
         // `[` is included for indexing operations,
-        // `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`)
+        // `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`),
+        // `as` is included for type casts
         let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or)
             || self.token.kind == token::Question
             || (self.token.kind == token::OpenDelim(Delimiter::Bracket)
-                && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket)));
+                && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket))) // excludes `[]`
+            || self.token.is_keyword(kw::As);
 
-        if !has_trailing_method && !has_trailing_operator {
+        if !has_dot_expr && !has_trailing_operator {
             // Nothing to recover here.
             return None;
         }
@@ -386,43 +401,40 @@ impl<'a> Parser<'a> {
         snapshot.restrictions.insert(Restrictions::IS_PAT);
 
         // Parse `?`, `.f`, `(arg0, arg1, ...)` or `[expr]` until they've all been eaten.
-        if let Ok(expr) = snapshot
+        let Ok(expr) = snapshot
             .parse_expr_dot_or_call_with(
                 self.mk_expr(pat_span, ExprKind::Dummy), // equivalent to transforming the parsed pattern into an `Expr`
                 pat_span,
                 AttrVec::new(),
             )
             .map_err(|err| err.cancel())
-        {
-            let non_assoc_span = expr.span;
-
-            // Parse an associative expression such as `+ expr`, `% expr`, ...
-            // Assignements, ranges and `|` are disabled by [`Restrictions::IS_PAT`].
-            let lhs = LhsExpr::Parsed { expr, starts_statement: false };
-            if let Ok(expr) = snapshot.parse_expr_assoc_with(0, lhs).map_err(|err| err.cancel()) {
-                // We got a valid expression.
-                self.restore_snapshot(snapshot);
-                self.restrictions.remove(Restrictions::IS_PAT);
-
-                let is_bound = is_end_bound
-                    // is_start_bound: either `..` or `)..`
-                    || self.token.is_range_separator()
-                    || self.token.kind == token::CloseDelim(Delimiter::Parenthesis)
-                        && self.look_ahead(1, Token::is_range_separator);
-
-                // Check that `parse_expr_assoc_with` didn't eat a rhs.
-                let is_method_call = has_trailing_method && non_assoc_span == expr.span;
-
-                return Some(self.dcx().emit_err(UnexpectedExpressionInPattern {
-                    span: expr.span,
-                    is_bound,
-                    is_method_call,
-                }));
-            }
-        }
+        else {
+            // We got a trailing method/operator, but that wasn't an expression.
+            return None;
+        };
+
+        // Parse an associative expression such as `+ expr`, `% expr`, ...
+        // Assignements, ranges and `|` are disabled by [`Restrictions::IS_PAT`].
+        let lhs = LhsExpr::Parsed { expr, starts_statement: false };
+        let Ok(expr) = snapshot.parse_expr_assoc_with(0, lhs).map_err(|err| err.cancel()) else {
+            // We got a trailing method/operator, but that wasn't an expression.
+            return None;
+        };
+
+        // We got a valid expression.
+        self.restore_snapshot(snapshot);
+        self.restrictions.remove(Restrictions::IS_PAT);
+
+        let is_bound = is_end_bound
+            // is_start_bound: either `..` or `)..`
+            || self.token.is_range_separator()
+            || self.token.kind == token::CloseDelim(Delimiter::Parenthesis)
+                && self.look_ahead(1, Token::is_range_separator);
 
-        // We got a trailing method/operator, but we couldn't parse an expression.
-        None
+        Some((
+            self.dcx().emit_err(UnexpectedExpressionInPattern { span: expr.span, is_bound }),
+            expr.span,
+        ))
     }
 
     /// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are
@@ -534,7 +546,7 @@ impl<'a> Parser<'a> {
                 self.parse_pat_tuple_struct(qself, path)?
             } else {
                 match self.maybe_recover_trailing_expr(span, false) {
-                    Some(guar) => PatKind::Err(guar),
+                    Some((guar, _)) => PatKind::Err(guar),
                     None => PatKind::Path(qself, path),
                 }
             }
@@ -567,10 +579,10 @@ impl<'a> Parser<'a> {
             // Try to parse everything else as literal with optional minus
             match self.parse_literal_maybe_minus() {
                 Ok(begin) => {
-                    let begin = match self.maybe_recover_trailing_expr(begin.span, false) {
-                        Some(guar) => self.mk_expr_err(begin.span, guar),
-                        None => begin,
-                    };
+                    let begin = self
+                        .maybe_recover_trailing_expr(begin.span, false)
+                        .map(|(guar, sp)| self.mk_expr_err(sp, guar))
+                        .unwrap_or(begin);
 
                     match self.parse_range_end() {
                         Some(form) => self.parse_pat_range_begin_with(begin, form)?,
@@ -700,7 +712,8 @@ impl<'a> Parser<'a> {
         // For backward compatibility, `(..)` is a tuple pattern as well.
         let paren_pattern =
             fields.len() == 1 && !(matches!(trailing_comma, Trailing::Yes) || fields[0].is_rest());
-        if paren_pattern {
+
+        let pat = if paren_pattern {
             let pat = fields.into_iter().next().unwrap();
             let close_paren = self.prev_token.span;
 
@@ -718,7 +731,7 @@ impl<'a> Parser<'a> {
                         },
                     });
 
-                    self.parse_pat_range_begin_with(begin.clone(), form)
+                    self.parse_pat_range_begin_with(begin.clone(), form)?
                 }
                 // recover ranges with parentheses around the `(start)..`
                 PatKind::Err(guar)
@@ -733,15 +746,20 @@ impl<'a> Parser<'a> {
                         },
                     });
 
-                    self.parse_pat_range_begin_with(self.mk_expr_err(pat.span, *guar), form)
+                    self.parse_pat_range_begin_with(self.mk_expr_err(pat.span, *guar), form)?
                 }
 
                 // (pat) with optional parentheses
-                _ => Ok(PatKind::Paren(pat)),
+                _ => PatKind::Paren(pat),
             }
         } else {
-            Ok(PatKind::Tuple(fields))
-        }
+            PatKind::Tuple(fields)
+        };
+
+        Ok(match self.maybe_recover_trailing_expr(open_paren.to(self.prev_token.span), false) {
+            None => pat,
+            Some((guar, _)) => PatKind::Err(guar),
+        })
     }
 
     /// Parse a mutable binding with the `mut` token already eaten.
@@ -991,7 +1009,7 @@ impl<'a> Parser<'a> {
         }
 
         Ok(match recovered {
-            Some(guar) => self.mk_expr_err(bound.span, guar),
+            Some((guar, sp)) => self.mk_expr_err(sp, guar),
             None => bound,
         })
     }
@@ -1060,7 +1078,7 @@ impl<'a> Parser<'a> {
         // but not `ident @ subpat` as `subpat` was already checked and `ident` continues with `@`.
 
         let pat = if sub.is_none()
-            && let Some(guar) = self.maybe_recover_trailing_expr(ident.span, false)
+            && let Some((guar, _)) = self.maybe_recover_trailing_expr(ident.span, false)
         {
             PatKind::Err(guar)
         } else {
diff --git a/tests/ui/parser/bad-name.rs b/tests/ui/parser/bad-name.rs
index 59432a1d9a5b9..fefe9122a08fb 100644
--- a/tests/ui/parser/bad-name.rs
+++ b/tests/ui/parser/bad-name.rs
@@ -1,5 +1,6 @@
-//@ error-pattern: expected
-
 fn main() {
   let x.y::<isize>.z foo;
+  //~^ error: field expressions cannot have generic arguments
+  //~| error: expected a pattern, found an expression
+  //~| error: expected one of `(`, `.`, `::`, `:`, `;`, `=`, `?`, `|`, or an operator, found `foo`
 }
diff --git a/tests/ui/parser/bad-name.stderr b/tests/ui/parser/bad-name.stderr
index e133d4e4839ce..3fc416dd5311f 100644
--- a/tests/ui/parser/bad-name.stderr
+++ b/tests/ui/parser/bad-name.stderr
@@ -1,8 +1,20 @@
-error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
-  --> $DIR/bad-name.rs:4:8
+error: field expressions cannot have generic arguments
+  --> $DIR/bad-name.rs:2:12
    |
 LL |   let x.y::<isize>.z foo;
-   |        ^ expected one of `:`, `;`, `=`, `@`, or `|`
+   |            ^^^^^^^
 
-error: aborting due to 1 previous error
+error: expected a pattern, found an expression
+  --> $DIR/bad-name.rs:2:7
+   |
+LL |   let x.y::<isize>.z foo;
+   |       ^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected one of `(`, `.`, `::`, `:`, `;`, `=`, `?`, `|`, or an operator, found `foo`
+  --> $DIR/bad-name.rs:2:22
+   |
+LL |   let x.y::<isize>.z foo;
+   |                      ^^^ expected one of 9 possible tokens
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/parser/pat-recover-exprs.rs b/tests/ui/parser/pat-recover-exprs.rs
deleted file mode 100644
index ecd471467e380..0000000000000
--- a/tests/ui/parser/pat-recover-exprs.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-fn main() {
-    match u8::MAX {
-        u8::MAX.abs() => (),
-        //~^ error: expected a pattern, found a method call
-        x.sqrt() @ .. => (),
-        //~^ error: expected a pattern, found a method call
-        //~| error: left-hand side of `@` must be a binding
-        z @ w @ v.u() => (),
-        //~^ error: expected a pattern, found a method call
-        y.ilog(3) => (),
-        //~^ error: expected a pattern, found a method call
-        n + 1 => (),
-        //~^ error: expected a pattern, found an expression
-        ("".f() + 14 * 8) => (),
-        //~^ error: expected a pattern, found an expression
-        0 | ((1) | 2) | 3 => (),
-        f?() => (),
-        //~^ error: expected a pattern, found an expression
-        (_ + 1) => (),
-        //~^ error: expected one of `)`, `,`, or `|`, found `+`
-    }
-
-    let 1 + 1 = 2;
-    //~^ error: expected a pattern, found an expression
-
-    let b = matches!(x, (x * x | x.f()) | x[0]);
-    //~^ error: expected one of `)`, `,`, `@`, or `|`, found `*`
-}
diff --git a/tests/ui/parser/pat-recover-exprs.stderr b/tests/ui/parser/pat-recover-exprs.stderr
deleted file mode 100644
index 787fd03b0c30d..0000000000000
--- a/tests/ui/parser/pat-recover-exprs.stderr
+++ /dev/null
@@ -1,76 +0,0 @@
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-exprs.rs:3:9
-   |
-LL |         u8::MAX.abs() => (),
-   |         ^^^^^^^^^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-exprs.rs:5:9
-   |
-LL |         x.sqrt() @ .. => (),
-   |         ^^^^^^^^ method calls are not allowed in patterns
-
-error: left-hand side of `@` must be a binding
-  --> $DIR/pat-recover-exprs.rs:5:9
-   |
-LL |         x.sqrt() @ .. => (),
-   |         --------^^^--
-   |         |          |
-   |         |          also a pattern
-   |         interpreted as a pattern, not a binding
-   |
-   = note: bindings are `x`, `mut x`, `ref x`, and `ref mut x`
-
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-exprs.rs:8:17
-   |
-LL |         z @ w @ v.u() => (),
-   |                 ^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-exprs.rs:10:9
-   |
-LL |         y.ilog(3) => (),
-   |         ^^^^^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern, found an expression
-  --> $DIR/pat-recover-exprs.rs:12:9
-   |
-LL |         n + 1 => (),
-   |         ^^^^^ arbitrary expressions are not allowed in patterns
-
-error: expected a pattern, found an expression
-  --> $DIR/pat-recover-exprs.rs:14:10
-   |
-LL |         ("".f() + 14 * 8) => (),
-   |          ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
-
-error: expected a pattern, found an expression
-  --> $DIR/pat-recover-exprs.rs:17:9
-   |
-LL |         f?() => (),
-   |         ^^^^ arbitrary expressions are not allowed in patterns
-
-error: expected one of `)`, `,`, or `|`, found `+`
-  --> $DIR/pat-recover-exprs.rs:19:12
-   |
-LL |         (_ + 1) => (),
-   |            ^ expected one of `)`, `,`, or `|`
-
-error: expected a pattern, found an expression
-  --> $DIR/pat-recover-exprs.rs:23:9
-   |
-LL |     let 1 + 1 = 2;
-   |         ^^^^^ arbitrary expressions are not allowed in patterns
-
-error: expected one of `)`, `,`, `@`, or `|`, found `*`
-  --> $DIR/pat-recover-exprs.rs:26:28
-   |
-LL |     let b = matches!(x, (x * x | x.f()) | x[0]);
-   |                            ^ expected one of `)`, `,`, `@`, or `|`
-  --> $SRC_DIR/core/src/macros/mod.rs:LL:COL
-   |
-   = note: while parsing argument for this `pat` macro fragment
-
-error: aborting due to 11 previous errors
-
diff --git a/tests/ui/parser/pat-recover-methodcalls.rs b/tests/ui/parser/pat-recover-methodcalls.rs
deleted file mode 100644
index 54104e9a53559..0000000000000
--- a/tests/ui/parser/pat-recover-methodcalls.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-struct Foo(String);
-struct Bar { baz: String }
-
-fn foo(foo: Foo) -> bool {
-    match foo {
-        Foo("hi".to_owned()) => true,
-        //~^ error: expected a pattern, found a method call
-        _ => false
-    }
-}
-
-fn bar(bar: Bar) -> bool {
-    match bar {
-        Bar { baz: "hi".to_owned() } => true,
-        //~^ error: expected a pattern, found a method call
-        _ => false
-    }
-}
-
-fn baz() { // issue #90121
-    let foo = vec!["foo".to_string()];
-
-    match foo.as_slice() {
-        &["foo".to_string()] => {}
-        //~^ error: expected a pattern, found a method call
-        _ => {}
-    };
-}
-
-fn main() {
-    if let (-1.some(4)) = (0, Some(4)) {}
-    //~^ error: expected a pattern, found a method call
-
-    if let (-1.Some(4)) = (0, Some(4)) {}
-    //~^ error: expected one of `)`, `,`, `...`, `..=`, `..`, or `|`, found `.`
-    //~| help: missing `,`
-}
diff --git a/tests/ui/parser/pat-recover-methodcalls.stderr b/tests/ui/parser/pat-recover-methodcalls.stderr
deleted file mode 100644
index 1f9ae81dc0c55..0000000000000
--- a/tests/ui/parser/pat-recover-methodcalls.stderr
+++ /dev/null
@@ -1,35 +0,0 @@
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-methodcalls.rs:6:13
-   |
-LL |         Foo("hi".to_owned()) => true,
-   |             ^^^^^^^^^^^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-methodcalls.rs:14:20
-   |
-LL |         Bar { baz: "hi".to_owned() } => true,
-   |                    ^^^^^^^^^^^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-methodcalls.rs:24:11
-   |
-LL |         &["foo".to_string()] => {}
-   |           ^^^^^^^^^^^^^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern, found a method call
-  --> $DIR/pat-recover-methodcalls.rs:31:13
-   |
-LL |     if let (-1.some(4)) = (0, Some(4)) {}
-   |             ^^^^^^^^^^ method calls are not allowed in patterns
-
-error: expected one of `)`, `,`, `...`, `..=`, `..`, or `|`, found `.`
-  --> $DIR/pat-recover-methodcalls.rs:34:15
-   |
-LL |     if let (-1.Some(4)) = (0, Some(4)) {}
-   |               ^
-   |               |
-   |               expected one of `)`, `,`, `...`, `..=`, `..`, or `|`
-   |               help: missing `,`
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/parser/recover/recover-pat-exprs.rs b/tests/ui/parser/recover/recover-pat-exprs.rs
new file mode 100644
index 0000000000000..0a771336abf05
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-exprs.rs
@@ -0,0 +1,81 @@
+// FieldExpression, TupleIndexingExpression
+fn field_access() {
+    match 0 {
+        x => (),
+        x.y => (), //~ error: expected a pattern, found an expression
+        x.0 => (), //~ error: expected a pattern, found an expression
+        x._0 => (), //~ error: expected a pattern, found an expression
+        x.0.1 => (), //~ error: expected a pattern, found an expression
+        x.4.y.17.__z => (), //~ error: expected a pattern, found an expression
+    }
+
+    { let x.0e0; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+    { let x.-0.0; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+    { let x.-0; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+}
+
+// MethodCallExpression, CallExpression, ErrorPropagationExpression
+fn method_call() {
+    match 0 {
+        x.f() => (), //~ error: expected a pattern, found an expression
+        x._f() => (), //~ error: expected a pattern, found an expression
+        x? => (), //~ error: expected a pattern, found an expression
+        ().f() => (), //~ error: expected a pattern, found an expression
+        (0, x)?.f() => (), //~ error: expected a pattern, found an expression
+        x.f().g() => (), //~ error: expected a pattern, found an expression
+        0.f()?.g()?? => (), //~ error: expected a pattern, found an expression
+    }
+}
+
+// TypeCastExpression
+fn type_cast() {
+    match 0 {
+        x as usize => (), //~ error: expected a pattern, found an expression
+        0 as usize => (), //~ error: expected a pattern, found an expression
+        x.f().0.4 as f32 => (), //~ error: expected a pattern, found an expression
+    }
+}
+
+// ArithmeticOrLogicalExpression
+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
+    }
+}
+
+const _: u32 = match 12 {
+    1 + 2 * PI.cos() => 2, //~ error: expected a pattern, found an expression
+    _ => 0,
+};
+
+fn main() {
+    match u8::MAX {
+        u8::MAX.abs() => (),
+        //~^ error: expected a pattern, found an expression
+        x.sqrt() @ .. => (),
+        //~^ error: expected a pattern, found an expression
+        //~| error: left-hand side of `@` must be a binding
+        z @ w @ v.u() => (),
+        //~^ error: expected a pattern, found an expression
+        y.ilog(3) => (),
+        //~^ error: expected a pattern, found an expression
+        n + 1 => (),
+        //~^ error: expected a pattern, found an expression
+        ("".f() + 14 * 8) => (),
+        //~^ error: expected a pattern, found an expression
+        0 | ((1) | 2) | 3 => (),
+        f?() => (),
+        //~^ error: expected a pattern, found an expression
+        (_ + 1) => (),
+        //~^ error: expected one of `)`, `,`, or `|`, found `+`
+    }
+
+    let 1 + 1 = 2;
+    //~^ error: expected a pattern, found an expression
+
+    let b = matches!(x, (x * x | x.f()) | x[0]);
+    //~^ error: expected one of `)`, `,`, `@`, or `|`, found `*`
+}
diff --git a/tests/ui/parser/recover/recover-pat-exprs.stderr b/tests/ui/parser/recover/recover-pat-exprs.stderr
new file mode 100644
index 0000000000000..1a6cc3e431600
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-exprs.stderr
@@ -0,0 +1,208 @@
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:5:9
+   |
+LL |         x.y => (),
+   |         ^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:6:9
+   |
+LL |         x.0 => (),
+   |         ^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:7:9
+   |
+LL |         x._0 => (),
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:8:9
+   |
+LL |         x.0.1 => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:9:9
+   |
+LL |         x.4.y.17.__z => (),
+   |         ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+  --> $DIR/recover-pat-exprs.rs:12:12
+   |
+LL |     { let x.0e0; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+  --> $DIR/recover-pat-exprs.rs:13:12
+   |
+LL |     { let x.-0.0; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+  --> $DIR/recover-pat-exprs.rs:14:12
+   |
+LL |     { let x.-0; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:20:9
+   |
+LL |         x.f() => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:21:9
+   |
+LL |         x._f() => (),
+   |         ^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:22:9
+   |
+LL |         x? => (),
+   |         ^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:23:9
+   |
+LL |         ().f() => (),
+   |         ^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:24:9
+   |
+LL |         (0, x)?.f() => (),
+   |         ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:25:9
+   |
+LL |         x.f().g() => (),
+   |         ^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:26:9
+   |
+LL |         0.f()?.g()?? => (),
+   |         ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:33:9
+   |
+LL |         x as usize => (),
+   |         ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:34:9
+   |
+LL |         0 as usize => (),
+   |         ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:35:9
+   |
+LL |         x.f().0.4 as f32 => (),
+   |         ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:42:9
+   |
+LL |         1 + 1 => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:43:10
+   |
+LL |         (1 + 2) * 3 => (),
+   |          ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:43:9
+   |
+LL |         (1 + 2) * 3 => (),
+   |         ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:50:5
+   |
+LL |     1 + 2 * PI.cos() => 2,
+   |     ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:56:9
+   |
+LL |         u8::MAX.abs() => (),
+   |         ^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:58:9
+   |
+LL |         x.sqrt() @ .. => (),
+   |         ^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: left-hand side of `@` must be a binding
+  --> $DIR/recover-pat-exprs.rs:58:9
+   |
+LL |         x.sqrt() @ .. => (),
+   |         --------^^^--
+   |         |          |
+   |         |          also a pattern
+   |         interpreted as a pattern, not a binding
+   |
+   = note: bindings are `x`, `mut x`, `ref x`, and `ref mut x`
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:61:17
+   |
+LL |         z @ w @ v.u() => (),
+   |                 ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:63:9
+   |
+LL |         y.ilog(3) => (),
+   |         ^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:65:9
+   |
+LL |         n + 1 => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:67:10
+   |
+LL |         ("".f() + 14 * 8) => (),
+   |          ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:70:9
+   |
+LL |         f?() => (),
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected one of `)`, `,`, or `|`, found `+`
+  --> $DIR/recover-pat-exprs.rs:72:12
+   |
+LL |         (_ + 1) => (),
+   |            ^ expected one of `)`, `,`, or `|`
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:76:9
+   |
+LL |     let 1 + 1 = 2;
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected one of `)`, `,`, `@`, or `|`, found `*`
+  --> $DIR/recover-pat-exprs.rs:79:28
+   |
+LL |     let b = matches!(x, (x * x | x.f()) | x[0]);
+   |                            ^ expected one of `)`, `,`, `@`, or `|`
+  --> $SRC_DIR/core/src/macros/mod.rs:LL:COL
+   |
+   = note: while parsing argument for this `pat` macro fragment
+
+error: aborting due to 33 previous errors
+
diff --git a/tests/ui/parser/recover/recover-pat-issues.rs b/tests/ui/parser/recover/recover-pat-issues.rs
new file mode 100644
index 0000000000000..5b900fe80e516
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-issues.rs
@@ -0,0 +1,46 @@
+struct Foo(String);
+struct Bar { baz: String }
+
+fn foo(foo: Foo) -> bool {
+    match foo {
+        Foo("hi".to_owned()) => true,
+        //~^ error: expected a pattern, found an expression
+        _ => false
+    }
+}
+
+fn bar(bar: Bar) -> bool {
+    match bar {
+        Bar { baz: "hi".to_owned() } => true,
+        //~^ error: expected a pattern, found an expression
+        _ => false
+    }
+}
+
+/// Issue #90121
+fn baz() {
+    let foo = vec!["foo".to_string()];
+
+    match foo.as_slice() {
+        &["foo".to_string()] => {}
+        //~^ error: expected a pattern, found an expression
+        _ => {}
+    };
+}
+
+/// Issue #104996
+fn qux() {
+    struct Magic(pub u16);
+    const MAGIC: Magic = Magic(42);
+
+    if let Some(MAGIC.0 as usize) = None::<usize> {}
+    //~^ error: expected a pattern, found an expression
+}
+
+fn main() {
+    if let (-1.some(4)) = (0, Some(4)) {}
+    //~^ error: expected a pattern, found an expression
+
+    if let (-1.Some(4)) = (0, Some(4)) {}
+    //~^ error: expected a pattern, found an expression
+}
diff --git a/tests/ui/parser/recover/recover-pat-issues.stderr b/tests/ui/parser/recover/recover-pat-issues.stderr
new file mode 100644
index 0000000000000..793091bb1f1c2
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-issues.stderr
@@ -0,0 +1,38 @@
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-issues.rs:6:13
+   |
+LL |         Foo("hi".to_owned()) => true,
+   |             ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+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
+
+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
+
+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
+
+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
+
+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
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/parser/recover/recover-pat-lets.rs b/tests/ui/parser/recover/recover-pat-lets.rs
new file mode 100644
index 0000000000000..6681cc25db37b
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-lets.rs
@@ -0,0 +1,20 @@
+fn main() {
+    let x = Some(2);
+
+    let x.expect("foo");
+    //~^ error: expected a pattern, found an expression
+
+    let x.unwrap(): u32;
+    //~^ error: expected a pattern, found an expression
+
+    let x[0] = 1;
+    //~^ error: expected a pattern, found an expression
+
+    let Some(1 + 1) = x else { //~ error: expected a pattern, found an expression
+        return;
+    };
+
+    if let Some(1 + 1) = x { //~ error: expected a pattern, found an expression
+        return;
+    }
+}
diff --git a/tests/ui/parser/recover/recover-pat-lets.stderr b/tests/ui/parser/recover/recover-pat-lets.stderr
new file mode 100644
index 0000000000000..b1d2a9b96d984
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-lets.stderr
@@ -0,0 +1,32 @@
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-lets.rs:4:9
+   |
+LL |     let x.expect("foo");
+   |         ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-lets.rs:7:9
+   |
+LL |     let x.unwrap(): u32;
+   |         ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-lets.rs:10:9
+   |
+LL |     let x[0] = 1;
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-lets.rs:13:14
+   |
+LL |     let Some(1 + 1) = x else {
+   |              ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-lets.rs:17:17
+   |
+LL |     if let Some(1 + 1) = x {
+   |                 ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/parser/pat-recover-ranges.rs b/tests/ui/parser/recover/recover-pat-ranges.rs
similarity index 89%
rename from tests/ui/parser/pat-recover-ranges.rs
rename to tests/ui/parser/recover/recover-pat-ranges.rs
index 7d77e950d905a..e3f061c625d3d 100644
--- a/tests/ui/parser/pat-recover-ranges.rs
+++ b/tests/ui/parser/recover/recover-pat-ranges.rs
@@ -22,8 +22,8 @@ fn main() {
         //~| warning: `...` range patterns are deprecated
         //~| warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
         0.x()..="y".z() => (),
-        //~^ error: expected a pattern range bound, found a method call
-        //~| error: expected a pattern range bound, found a method call
+        //~^ error: expected a pattern range bound, found an expression
+        //~| error: expected a pattern range bound, found an expression
     };
 }
 
diff --git a/tests/ui/parser/pat-recover-ranges.stderr b/tests/ui/parser/recover/recover-pat-ranges.stderr
similarity index 77%
rename from tests/ui/parser/pat-recover-ranges.stderr
rename to tests/ui/parser/recover/recover-pat-ranges.stderr
index a7d62bd7f8ad2..62ef7a8a908c2 100644
--- a/tests/ui/parser/pat-recover-ranges.stderr
+++ b/tests/ui/parser/recover/recover-pat-ranges.stderr
@@ -1,5 +1,5 @@
 error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:4:13
+  --> $DIR/recover-pat-ranges.rs:4:13
    |
 LL |         0..=(1) => (),
    |             ^ ^
@@ -11,7 +11,7 @@ LL +         0..=1 => (),
    |
 
 error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:6:9
+  --> $DIR/recover-pat-ranges.rs:6:9
    |
 LL |         (-12)..=4 => (),
    |         ^   ^
@@ -23,7 +23,7 @@ LL +         -12..=4 => (),
    |
 
 error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:8:9
+  --> $DIR/recover-pat-ranges.rs:8:9
    |
 LL |         (0)..=(-4) => (),
    |         ^ ^
@@ -35,7 +35,7 @@ LL +         0..=(-4) => (),
    |
 
 error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:8:15
+  --> $DIR/recover-pat-ranges.rs:8:15
    |
 LL |         (0)..=(-4) => (),
    |               ^  ^
@@ -47,13 +47,13 @@ LL +         (0)..=-4 => (),
    |
 
 error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-ranges.rs:11:12
+  --> $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/pat-recover-ranges.rs:13:9
+  --> $DIR/recover-pat-ranges.rs:13:9
    |
 LL |         (4).. => (),
    |         ^ ^
@@ -65,13 +65,13 @@ LL +         4.. => (),
    |
 
 error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-ranges.rs:15:10
+  --> $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/pat-recover-ranges.rs:15:9
+  --> $DIR/recover-pat-ranges.rs:15:9
    |
 LL |         (-4 + 0).. => (),
    |         ^      ^
@@ -83,13 +83,13 @@ LL +         -4 + 0.. => (),
    |
 
 error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-ranges.rs:18:10
+  --> $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/pat-recover-ranges.rs:18:9
+  --> $DIR/recover-pat-ranges.rs:18:9
    |
 LL |         (1 + 4)...1 * 2 => (),
    |         ^     ^
@@ -101,25 +101,25 @@ LL +         1 + 4...1 * 2 => (),
    |
 
 error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-ranges.rs:18:19
+  --> $DIR/recover-pat-ranges.rs:18:19
    |
 LL |         (1 + 4)...1 * 2 => (),
    |                   ^^^^^ arbitrary expressions are not allowed in patterns
 
-error: expected a pattern range bound, found a method call
-  --> $DIR/pat-recover-ranges.rs:24:9
+error: expected a pattern range bound, found an expression
+  --> $DIR/recover-pat-ranges.rs:24:9
    |
 LL |         0.x()..="y".z() => (),
-   |         ^^^^^ method calls are not allowed in patterns
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
 
-error: expected a pattern range bound, found a method call
-  --> $DIR/pat-recover-ranges.rs:24:17
+error: expected a pattern range bound, found an expression
+  --> $DIR/recover-pat-ranges.rs:24:17
    |
 LL |         0.x()..="y".z() => (),
-   |                 ^^^^^^^ method calls are not allowed in patterns
+   |                 ^^^^^^^ arbitrary expressions are not allowed in patterns
 
 warning: `...` range patterns are deprecated
-  --> $DIR/pat-recover-ranges.rs:18:16
+  --> $DIR/recover-pat-ranges.rs:18:16
    |
 LL |         (1 + 4)...1 * 2 => (),
    |                ^^^ help: use `..=` for an inclusive range
diff --git a/tests/ui/parser/pat-recover-wildcards.rs b/tests/ui/parser/recover/recover-pat-wildcards.rs
similarity index 100%
rename from tests/ui/parser/pat-recover-wildcards.rs
rename to tests/ui/parser/recover/recover-pat-wildcards.rs
diff --git a/tests/ui/parser/pat-recover-wildcards.stderr b/tests/ui/parser/recover/recover-pat-wildcards.stderr
similarity index 79%
rename from tests/ui/parser/pat-recover-wildcards.stderr
rename to tests/ui/parser/recover/recover-pat-wildcards.stderr
index 2b0c9bbc5be86..913e366896149 100644
--- a/tests/ui/parser/pat-recover-wildcards.stderr
+++ b/tests/ui/parser/recover/recover-pat-wildcards.stderr
@@ -1,35 +1,35 @@
 error: expected one of `=>`, `if`, or `|`, found `+`
-  --> $DIR/pat-recover-wildcards.rs:5:11
+  --> $DIR/recover-pat-wildcards.rs:5:11
    |
 LL |         _ + 1 => ()
    |           ^ expected one of `=>`, `if`, or `|`
 
 error: expected one of `)`, `,`, or `|`, found `%`
-  --> $DIR/pat-recover-wildcards.rs:11:12
+  --> $DIR/recover-pat-wildcards.rs:11:12
    |
 LL |         (_ % 4) => ()
    |            ^ expected one of `)`, `,`, or `|`
 
 error: expected one of `=>`, `if`, or `|`, found `.`
-  --> $DIR/pat-recover-wildcards.rs:17:10
+  --> $DIR/recover-pat-wildcards.rs:17:10
    |
 LL |         _.x() => ()
    |          ^ expected one of `=>`, `if`, or `|`
 
 error: expected one of `=>`, `if`, or `|`, found `..=`
-  --> $DIR/pat-recover-wildcards.rs:23:10
+  --> $DIR/recover-pat-wildcards.rs:23:10
    |
 LL |         _..=4 => ()
    |          ^^^ expected one of `=>`, `if`, or `|`
 
 error: expected one of `=>`, `if`, or `|`, found reserved identifier `_`
-  --> $DIR/pat-recover-wildcards.rs:29:11
+  --> $DIR/recover-pat-wildcards.rs:29:11
    |
 LL |         .._ => ()
    |           ^ expected one of `=>`, `if`, or `|`
 
 error[E0586]: inclusive range with no end
-  --> $DIR/pat-recover-wildcards.rs:35:10
+  --> $DIR/recover-pat-wildcards.rs:35:10
    |
 LL |         0..._ => ()
    |          ^^^ help: use `..` instead
@@ -37,31 +37,31 @@ LL |         0..._ => ()
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 
 error: expected one of `=>`, `if`, or `|`, found reserved identifier `_`
-  --> $DIR/pat-recover-wildcards.rs:35:13
+  --> $DIR/recover-pat-wildcards.rs:35:13
    |
 LL |         0..._ => ()
    |             ^ expected one of `=>`, `if`, or `|`
 
 error: expected one of `)`, `,`, or `|`, found `*`
-  --> $DIR/pat-recover-wildcards.rs:43:12
+  --> $DIR/recover-pat-wildcards.rs:43:12
    |
 LL |         (_ * 0)..5 => ()
    |            ^ expected one of `)`, `,`, or `|`
 
 error: expected one of `=>`, `if`, or `|`, found `(`
-  --> $DIR/pat-recover-wildcards.rs:49:11
+  --> $DIR/recover-pat-wildcards.rs:49:11
    |
 LL |         ..(_) => ()
    |           ^ expected one of `=>`, `if`, or `|`
 
 error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-wildcards.rs:55:14
+  --> $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/pat-recover-wildcards.rs:55:13
+  --> $DIR/recover-pat-wildcards.rs:55:13
    |
 LL |         4..=(2 + _) => ()
    |             ^     ^