Auto merge of #123877 - ShE3py:expr-in-pats-2, r=fmease

Further improve diagnostics for expressions in pattern position

Follow-up of #118625, see #121697.

```rs
fn main() {
    match 'b' {
        y.0.0.1.z().f()? as u32 => {},
    }
}
```
Before:
```
error: expected one of `=>`, ``@`,` `if`, or `|`, found `.`
 --> src/main.rs:3:10
  |
3 |         y.0.0.1.z().f()? as u32 => {},
  |          ^ expected one of `=>`, ``@`,` `if`, or `|`
```
After:
```
error: expected a pattern, found an expression
 --> src/main.rs:3:9
  |
3 |         y.0.0.1.z().f()? as u32 => {},
  |         ^^^^^^^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
  |
help: consider moving the expression to a match arm guard
  |
3 |         val if val == y.0.0.1.z().f()? as u32 => {},
  |         ~~~ +++++++++++++++++++++++++++++++++
help: consider extracting the expression into a `const`
  |
2 +     const VAL: /* Type */ = y.0.0.1.z().f()? as u32;
3 ~     match 'b' {
4 ~         VAL => {},
  |
help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
  |
3 |         const { y.0.0.1.z().f()? as u32 } => {},
  |         +++++++                         +
```

---

r? fmease
`@rustbot` label +A-diagnostics +A-parser +A-patterns +C-enhancement

21 files changed, 1418 insertions, 340 deletions

diff --git a/tests/ui/half-open-range-patterns/range_pat_interactions1.stderr b/tests/ui/half-open-range-patterns/range_pat_interactions1.stderr
index c14021e009b..9831348de75 100644
--- a/tests/ui/half-open-range-patterns/range_pat_interactions1.stderr
+++ b/tests/ui/half-open-range-patterns/range_pat_interactions1.stderr
@@ -3,6 +3,17 @@ 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: consider extracting the expression into a `const`
+   |
+LL +         const VAL: /* Type */ = 5+1;
+LL ~         match x as i32 {
+LL ~             0..VAL => errors_only.push(x),
+   |
+help: consider wrapping the expression in an 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
diff --git a/tests/ui/half-open-range-patterns/range_pat_interactions2.stderr b/tests/ui/half-open-range-patterns/range_pat_interactions2.stderr
index 136296fa5b0..1b5e875cccb 100644
--- a/tests/ui/half-open-range-patterns/range_pat_interactions2.stderr
+++ b/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,23 @@ 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: consider extracting the expression into a `const`
+   |
+LL +         const VAL: /* Type */ = 5+1;
+LL ~         match x as i32 {
+LL ~             0..=(VAL) => errors_only.push(x),
+   |
+help: consider wrapping the expression in an 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
    |
diff --git a/tests/ui/parser/bad-name.rs b/tests/ui/parser/bad-name.rs
index 59432a1d9a5..fefe9122a08 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 e133d4e4839..3fc416dd531 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/issues/issue-24375.stderr b/tests/ui/parser/issues/issue-24375.stderr
index e6ef07d13fd..a25c277d78a 100644
--- a/tests/ui/parser/issues/issue-24375.stderr
+++ b/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: consider moving the expression to a match arm guard
+   |
+LL |         val if val == tmp[0] => {}
+   |         ~~~ ++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = tmp[0];
+LL ~     match z {
+LL ~         VAL => {}
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { tmp[0] } => {}
+   |         +++++++        +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-lt-bracket-6.stderr b/tests/ui/parser/pat-lt-bracket-6.stderr
index 10c638a63e4..892883c4aed 100644
--- a/tests/ui/parser/pat-lt-bracket-6.stderr
+++ b/tests/ui/parser/pat-lt-bracket-6.stderr
@@ -1,8 +1,8 @@
 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
 
 error[E0308]: mismatched types
   --> $DIR/pat-lt-bracket-6.rs:10:30
diff --git a/tests/ui/parser/pat-recover-exprs.rs b/tests/ui/parser/pat-recover-exprs.rs
deleted file mode 100644
index ecd471467e3..00000000000
--- 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 787fd03b0c3..00000000000
--- 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 54104e9a535..00000000000
--- 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 1f9ae81dc0c..00000000000
--- 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/pat-recover-ranges.stderr b/tests/ui/parser/pat-recover-ranges.stderr
deleted file mode 100644
index a7d62bd7f8a..00000000000
--- a/tests/ui/parser/pat-recover-ranges.stderr
+++ /dev/null
@@ -1,132 +0,0 @@
-error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:4:13
-   |
-LL |         0..=(1) => (),
-   |             ^ ^
-   |
-help: remove these parentheses
-   |
-LL -         0..=(1) => (),
-LL +         0..=1 => (),
-   |
-
-error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:6:9
-   |
-LL |         (-12)..=4 => (),
-   |         ^   ^
-   |
-help: remove these parentheses
-   |
-LL -         (-12)..=4 => (),
-LL +         -12..=4 => (),
-   |
-
-error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:8:9
-   |
-LL |         (0)..=(-4) => (),
-   |         ^ ^
-   |
-help: remove these parentheses
-   |
-LL -         (0)..=(-4) => (),
-LL +         0..=(-4) => (),
-   |
-
-error: range pattern bounds cannot have parentheses
-  --> $DIR/pat-recover-ranges.rs:8:15
-   |
-LL |         (0)..=(-4) => (),
-   |               ^  ^
-   |
-help: remove these parentheses
-   |
-LL -         (0)..=(-4) => (),
-LL +         (0)..=-4 => (),
-   |
-
-error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-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
-   |
-LL |         (4).. => (),
-   |         ^ ^
-   |
-help: remove these parentheses
-   |
-LL -         (4).. => (),
-LL +         4.. => (),
-   |
-
-error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-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
-   |
-LL |         (-4 + 0).. => (),
-   |         ^      ^
-   |
-help: remove these parentheses
-   |
-LL -         (-4 + 0).. => (),
-LL +         -4 + 0.. => (),
-   |
-
-error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-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
-   |
-LL |         (1 + 4)...1 * 2 => (),
-   |         ^     ^
-   |
-help: remove these parentheses
-   |
-LL -         (1 + 4)...1 * 2 => (),
-LL +         1 + 4...1 * 2 => (),
-   |
-
-error: expected a pattern range bound, found an expression
-  --> $DIR/pat-recover-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
-   |
-LL |         0.x()..="y".z() => (),
-   |         ^^^^^ method calls are not allowed in patterns
-
-error: expected a pattern range bound, found a method call
-  --> $DIR/pat-recover-ranges.rs:24:17
-   |
-LL |         0.x()..="y".z() => (),
-   |                 ^^^^^^^ method calls are not allowed in patterns
-
-warning: `...` range patterns are deprecated
-  --> $DIR/pat-recover-ranges.rs:18:16
-   |
-LL |         (1 + 4)...1 * 2 => (),
-   |                ^^^ help: use `..=` for an inclusive range
-   |
-   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
-   = note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
-
-error: aborting due to 13 previous errors; 1 warning emitted
-
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 00000000000..e5e25df0c01
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-exprs.rs
@@ -0,0 +1,106 @@
+// 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 `.`
+
+    { let x.0u32; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+    { let x.0.0_f64; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+}
+
+// IndexExpression, ArrayExpression
+fn array_indexing() {
+    match 0 {
+        x[0] => (), //~ error: expected a pattern, found an expression
+        x[..] => (), //~ error: expected a pattern, found an expression
+    }
+
+    { let x[0, 1, 2]; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
+    { let x[0; 20]; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
+    { let x[]; } //~ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
+    { let (x[]); } //~ error: expected one of `)`, `,`, `@`, or `|`, found `[`
+    //~^ missing `,`
+}
+
+// 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, also check if parentheses are added as needed
+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
+        x.0 > 2 => (), //~ error: expected a pattern, found an expression
+        x.0 == 2 => (), //~ error: expected a pattern, found an expression
+    }
+
+    // preexisting match arm guard
+    match (0, 0) {
+        (x, y.0 > 2) if x != 0 => (), //~ error: expected a pattern, found an expression
+        (x, y.0 > 2) if x != 0 || x != 1 => (), //~ 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 00000000000..63956f35c07
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-exprs.stderr
@@ -0,0 +1,772 @@
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:5:9
+   |
+LL |         x.y => (),
+   |         ^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.y => (),
+   |         ~~~ +++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.y;
+LL ~     match 0 {
+LL |         x => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.y } => (),
+   |         +++++++     +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:6:9
+   |
+LL |         x.0 => (),
+   |         ^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.0 => (),
+   |         ~~~ +++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.0;
+LL ~     match 0 {
+LL |         x => (),
+LL |         x.y => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.0 } => (),
+   |         +++++++     +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:7:9
+   |
+LL |         x._0 => (),
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x._0 => (),
+   |         ~~~ ++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x._0;
+LL ~     match 0 {
+LL |         x => (),
+LL |         x.y => (),
+LL |         x.0 => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x._0 } => (),
+   |         +++++++      +
+
+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
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.0.1 => (),
+   |         ~~~ +++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.0.1;
+LL ~     match 0 {
+LL |         x => (),
+...
+LL |         x._0 => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.0.1 } => (),
+   |         +++++++       +
+
+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
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.4.y.17.__z => (),
+   |         ~~~ ++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.4.y.17.__z;
+LL ~     match 0 {
+LL |         x => (),
+...
+LL |         x.0.1 => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.4.y.17.__z } => (),
+   |         +++++++              +
+
+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 one of `:`, `;`, `=`, `@`, or `|`, found `.`
+  --> $DIR/recover-pat-exprs.rs:16:12
+   |
+LL |     { let x.0u32; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
+  --> $DIR/recover-pat-exprs.rs:17:12
+   |
+LL |     { let x.0.0_f64; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:23:9
+   |
+LL |         x[0] => (),
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x[0] => (),
+   |         ~~~ ++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x[0];
+LL ~     match 0 {
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x[0] } => (),
+   |         +++++++      +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:24:9
+   |
+LL |         x[..] => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x[..] => (),
+   |         ~~~ +++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x[..];
+LL ~     match 0 {
+LL |         x[0] => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x[..] } => (),
+   |         +++++++       +
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
+  --> $DIR/recover-pat-exprs.rs:27:12
+   |
+LL |     { let x[0, 1, 2]; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
+  --> $DIR/recover-pat-exprs.rs:28:12
+   |
+LL |     { let x[0; 20]; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
+  --> $DIR/recover-pat-exprs.rs:29:12
+   |
+LL |     { let x[]; }
+   |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
+
+error: expected one of `)`, `,`, `@`, or `|`, found `[`
+  --> $DIR/recover-pat-exprs.rs:30:13
+   |
+LL |     { let (x[]); }
+   |             ^
+   |             |
+   |             expected one of `)`, `,`, `@`, or `|`
+   |             help: missing `,`
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:37:9
+   |
+LL |         x.f() => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.f() => (),
+   |         ~~~ +++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.f();
+LL ~     match 0 {
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.f() } => (),
+   |         +++++++       +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:38:9
+   |
+LL |         x._f() => (),
+   |         ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x._f() => (),
+   |         ~~~ ++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x._f();
+LL ~     match 0 {
+LL |         x.f() => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x._f() } => (),
+   |         +++++++        +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:39:9
+   |
+LL |         x? => (),
+   |         ^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x? => (),
+   |         ~~~ ++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x?;
+LL ~     match 0 {
+LL |         x.f() => (),
+LL |         x._f() => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x? } => (),
+   |         +++++++    +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:40:9
+   |
+LL |         ().f() => (),
+   |         ^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == ().f() => (),
+   |         ~~~ ++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = ().f();
+LL ~     match 0 {
+LL |         x.f() => (),
+LL |         x._f() => (),
+LL |         x? => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { ().f() } => (),
+   |         +++++++        +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:41:9
+   |
+LL |         (0, x)?.f() => (),
+   |         ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == (0, x)?.f() => (),
+   |         ~~~ +++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = (0, x)?.f();
+LL ~     match 0 {
+LL |         x.f() => (),
+...
+LL |         ().f() => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { (0, x)?.f() } => (),
+   |         +++++++             +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:42:9
+   |
+LL |         x.f().g() => (),
+   |         ^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.f().g() => (),
+   |         ~~~ +++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.f().g();
+LL ~     match 0 {
+LL |         x.f() => (),
+...
+LL |         (0, x)?.f() => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.f().g() } => (),
+   |         +++++++           +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:43:9
+   |
+LL |         0.f()?.g()?? => (),
+   |         ^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == 0.f()?.g()?? => (),
+   |         ~~~ ++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 0.f()?.g()??;
+LL ~     match 0 {
+LL |         x.f() => (),
+...
+LL |         x.f().g() => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { 0.f()?.g()?? } => (),
+   |         +++++++              +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:50:9
+   |
+LL |         x as usize => (),
+   |         ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x as usize => (),
+   |         ~~~ ++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x as usize;
+LL ~     match 0 {
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x as usize } => (),
+   |         +++++++            +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:51:9
+   |
+LL |         0 as usize => (),
+   |         ^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == 0 as usize => (),
+   |         ~~~ ++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 0 as usize;
+LL ~     match 0 {
+LL |         x as usize => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { 0 as usize } => (),
+   |         +++++++            +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:52:9
+   |
+LL |         x.f().0.4 as f32 => (),
+   |         ^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == x.f().0.4 as f32 => (),
+   |         ~~~ ++++++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.f().0.4 as f32;
+LL ~     match 0 {
+LL |         x as usize => (),
+LL |         0 as usize => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.f().0.4 as f32 } => (),
+   |         +++++++                  +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:59:9
+   |
+LL |         1 + 1 => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == 1 + 1 => (),
+   |         ~~~ +++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 1 + 1;
+LL ~     match 0 {
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { 1 + 1 } => (),
+   |         +++++++       +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:60:9
+   |
+LL |         (1 + 2) * 3 => (),
+   |         ^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == (1 + 2) * 3 => (),
+   |         ~~~ +++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = (1 + 2) * 3;
+LL ~     match 0 {
+LL |         1 + 1 => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { (1 + 2) * 3 } => (),
+   |         +++++++             +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:63:9
+   |
+LL |         x.0 > 2 => (),
+   |         ^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == (x.0 > 2) => (),
+   |         ~~~ +++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.0 > 2;
+LL ~     match 0 {
+LL |         1 + 1 => (),
+...
+LL |
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.0 > 2 } => (),
+   |         +++++++         +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:64:9
+   |
+LL |         x.0 == 2 => (),
+   |         ^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == (x.0 == 2) => (),
+   |         ~~~ ++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = x.0 == 2;
+LL ~     match 0 {
+LL |         1 + 1 => (),
+...
+LL |         x.0 > 2 => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { x.0 == 2 } => (),
+   |         +++++++          +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:69:13
+   |
+LL |         (x, y.0 > 2) if x != 0 => (),
+   |             ^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to the match arm guard
+   |
+LL |         (x, val) if x != 0 && val == (y.0 > 2) => (),
+   |             ~~~            +++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = y.0 > 2;
+LL ~     match (0, 0) {
+LL ~         (x, VAL) if x != 0 => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         (x, const { y.0 > 2 }) if x != 0 => (),
+   |             +++++++         +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:70:13
+   |
+LL |         (x, y.0 > 2) if x != 0 || x != 1 => (),
+   |             ^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to the match arm guard
+   |
+LL |         (x, val) if (x != 0 || x != 1) && val == (y.0 > 2) => (),
+   |             ~~~     +                +++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = y.0 > 2;
+LL ~     match (0, 0) {
+LL |         (x, y.0 > 2) if x != 0 => (),
+LL ~         (x, VAL) if x != 0 || x != 1 => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         (x, const { y.0 > 2 }) if x != 0 || x != 1 => (),
+   |             +++++++         +
+
+error: left-hand side of `@` must be a binding
+  --> $DIR/recover-pat-exprs.rs:83: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 one of `)`, `,`, or `|`, found `+`
+  --> $DIR/recover-pat-exprs.rs:97:12
+   |
+LL |         (_ + 1) => (),
+   |            ^ expected one of `)`, `,`, or `|`
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:81:9
+   |
+LL |         u8::MAX.abs() => (),
+   |         ^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == u8::MAX.abs() => (),
+   |         ~~~ +++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = u8::MAX.abs();
+LL ~     match u8::MAX {
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { u8::MAX.abs() } => (),
+   |         +++++++               +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:86:17
+   |
+LL |         z @ w @ v.u() => (),
+   |                 ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         z @ w @ val if val == v.u() => (),
+   |                 ~~~ +++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = v.u();
+LL ~     match u8::MAX {
+LL |         u8::MAX.abs() => (),
+...
+LL |
+LL ~         z @ w @ VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         z @ w @ const { v.u() } => (),
+   |                 +++++++       +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:88:9
+   |
+LL |         y.ilog(3) => (),
+   |         ^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == y.ilog(3) => (),
+   |         ~~~ +++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = y.ilog(3);
+LL ~     match u8::MAX {
+LL |         u8::MAX.abs() => (),
+...
+LL |
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { y.ilog(3) } => (),
+   |         +++++++           +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:90:9
+   |
+LL |         n + 1 => (),
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == n + 1 => (),
+   |         ~~~ +++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = n + 1;
+LL ~     match u8::MAX {
+LL |         u8::MAX.abs() => (),
+...
+LL |
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { n + 1 } => (),
+   |         +++++++       +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:92:10
+   |
+LL |         ("".f() + 14 * 8) => (),
+   |          ^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         (val) if val == "".f() + 14 * 8 => (),
+   |          ~~~  +++++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = "".f() + 14 * 8;
+LL ~     match u8::MAX {
+LL |         u8::MAX.abs() => (),
+...
+LL |
+LL ~         (VAL) => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         (const { "".f() + 14 * 8 }) => (),
+   |          +++++++                 +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:95:9
+   |
+LL |         f?() => (),
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         val if val == f?() => (),
+   |         ~~~ ++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = f?();
+LL ~     match u8::MAX {
+LL |         u8::MAX.abs() => (),
+...
+LL |         0 | ((1) | 2) | 3 => (),
+LL ~         VAL => (),
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |         const { f?() } => (),
+   |         +++++++      +
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:101:9
+   |
+LL |     let 1 + 1 = 2;
+   |         ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected one of `)`, `,`, `@`, or `|`, found `*`
+  --> $DIR/recover-pat-exprs.rs:104: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: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:60:10
+   |
+LL |         (1 + 2) * 3 => (),
+   |          ^^^^^ arbitrary expressions are not allowed in patterns
+
+error: expected a pattern, found an expression
+  --> $DIR/recover-pat-exprs.rs:75: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:83:9
+   |
+LL |         x.sqrt() @ .. => (),
+   |         ^^^^^^^^ arbitrary expressions are not allowed in patterns
+
+error: aborting due to 45 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 00000000000..5b900fe80e5
--- /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 00000000000..596bff21395
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-issues.stderr
@@ -0,0 +1,113 @@
+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
+   |
+help: consider moving the expression to a match arm guard
+   |
+LL |         Foo(val) if val == "hi".to_owned() => true,
+   |             ~~~  +++++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = "hi".to_owned();
+LL ~     match foo {
+LL ~         Foo(VAL) => true,
+   |
+help: consider wrapping the expression in an 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: consider moving the expression to a match arm guard
+   |
+LL |         Bar { baz } if baz == "hi".to_owned() => true,
+   |               ~~~   +++++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const BAZ: /* Type */ = "hi".to_owned();
+LL ~     match bar {
+LL ~         Bar { baz: BAZ } => true,
+   |
+help: consider wrapping the expression in an 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: consider moving the expression to a match arm guard
+   |
+LL |         &[val] if val == "foo".to_string() => {}
+   |           ~~~  +++++++++++++++++++++++++++
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = "foo".to_string();
+LL ~     match foo.as_slice() {
+LL ~         &[VAL] => {}
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = MAGIC.0 as usize;
+LL ~     if let Some(VAL) = None::<usize> {}
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = -1.some(4);
+LL ~     if let (VAL) = (0, Some(4)) {}
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = -1.Some(4);
+LL ~     if let (VAL) = (0, Some(4)) {}
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     if let (const { -1.Some(4) }) = (0, Some(4)) {}
+   |             +++++++            +
+
+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 00000000000..6681cc25db3
--- /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 00000000000..e54586b0924
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-lets.stderr
@@ -0,0 +1,52 @@
+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
+   |
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 1 + 1;
+LL ~     let Some(VAL) = x else {
+   |
+help: consider wrapping the expression in an 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
+   |
+LL |     if let Some(1 + 1) = x {
+   |                 ^^^^^ arbitrary expressions are not allowed in patterns
+   |
+help: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 1 + 1;
+LL ~     if let Some(VAL) = x {
+   |
+help: consider wrapping the expression in an inline `const` (requires `#![feature(inline_const_pat)]`)
+   |
+LL |     if let Some(const { 1 + 1 }) = x {
+   |                 +++++++       +
+
+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
index 7d77e950d90..e3f061c625d 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/recover/recover-pat-ranges.stderr b/tests/ui/parser/recover/recover-pat-ranges.stderr
new file mode 100644
index 00000000000..088f83b0ccb
--- /dev/null
+++ b/tests/ui/parser/recover/recover-pat-ranges.stderr
@@ -0,0 +1,216 @@
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:4:13
+   |
+LL |         0..=(1) => (),
+   |             ^ ^
+   |
+help: remove these parentheses
+   |
+LL -         0..=(1) => (),
+LL +         0..=1 => (),
+   |
+
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:6:9
+   |
+LL |         (-12)..=4 => (),
+   |         ^   ^
+   |
+help: remove these parentheses
+   |
+LL -         (-12)..=4 => (),
+LL +         -12..=4 => (),
+   |
+
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:8:9
+   |
+LL |         (0)..=(-4) => (),
+   |         ^ ^
+   |
+help: remove these parentheses
+   |
+LL -         (0)..=(-4) => (),
+LL +         0..=(-4) => (),
+   |
+
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:8:15
+   |
+LL |         (0)..=(-4) => (),
+   |               ^  ^
+   |
+help: remove these parentheses
+   |
+LL -         (0)..=(-4) => (),
+LL +         (0)..=-4 => (),
+   |
+
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:13:9
+   |
+LL |         (4).. => (),
+   |         ^ ^
+   |
+help: remove these parentheses
+   |
+LL -         (4).. => (),
+LL +         4.. => (),
+   |
+
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:15:9
+   |
+LL |         (-4 + 0).. => (),
+   |         ^      ^
+   |
+help: remove these parentheses
+   |
+LL -         (-4 + 0).. => (),
+LL +         -4 + 0.. => (),
+   |
+
+error: range pattern bounds cannot have parentheses
+  --> $DIR/recover-pat-ranges.rs:18:9
+   |
+LL |         (1 + 4)...1 * 2 => (),
+   |         ^     ^
+   |
+help: remove these parentheses
+   |
+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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 1 + 2;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         ..=VAL => (),
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = -4 + 0;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         (VAL).. => (),
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 1 + 4;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         (VAL)...1 * 2 => (),
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 1 * 2;
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         (1 + 4)...VAL => (),
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 0.x();
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         VAL..="y".z() => (),
+   |
+help: consider wrapping the expression in an 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = "y".z();
+LL ~     match -1 {
+LL |         0..=1 => (),
+...
+LL |
+LL ~         0.x()..=VAL => (),
+   |
+help: consider wrapping the expression in an 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
+   |
+LL |         (1 + 4)...1 * 2 => (),
+   |                ^^^ help: use `..=` for an inclusive range
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
+
+error: aborting due to 13 previous errors; 1 warning emitted
+
diff --git a/tests/ui/parser/pat-recover-wildcards.rs b/tests/ui/parser/recover/recover-pat-wildcards.rs
index f506e2223d6..f506e2223d6 100644
--- a/tests/ui/parser/pat-recover-wildcards.rs
+++ b/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
index e36ff237bb0..30307726a97 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..._ => ()
    |          ^^^
@@ -42,31 +42,25 @@ LL +         0.._ => ()
    |
 
 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
-   |
-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 + _) => ()
    |             ^     ^
@@ -77,6 +71,23 @@ 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: consider extracting the expression into a `const`
+   |
+LL +     const VAL: /* Type */ = 2 + _;
+LL ~     match 9 {
+LL ~         4..=(VAL) => ()
+   |
+help: consider wrapping the expression in an 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`.