Stash UnexpectedExpressionInPattern

ShE3py · ShE3py · commit aa09ee808adb · 2024-04-12T23:29:11.000+02:00
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
@@ -523,6 +523,8 @@ pub enum StashKey {
     /// Query cycle detected, stashing in favor of a better error.
     Cycle,
     UndeterminedMacroResolution,
+    /// Used by `Parser::maybe_recover_trailing_expr`
+    ExprInPat,
 }
 
 fn default_track_diagnostic<R>(diag: DiagInner, f: &mut dyn FnMut(DiagInner) -> R) -> R {
@@ -807,6 +809,23 @@ impl DiagCtxt {
         Some(Diag::new_diagnostic(self, diag))
     }
 
+    /// Steals a previously stashed error with the given `Span` and
+    /// [`StashKey`] as the key, and cancels it if found.
+    /// Panics if the found diagnostic's level isn't `Level::Error`.
+    pub fn steal_err(&self, span: Span, key: StashKey, _: ErrorGuaranteed) -> bool {
+        let key = (span.with_parent(None), key);
+        // FIXME(#120456) - is `swap_remove` correct?
+        self.inner
+            .borrow_mut()
+            .stashed_diagnostics
+            .swap_remove(&key)
+            .inspect(|(diag, guar)| {
+                assert_eq!(diag.level, Error);
+                assert!(guar.is_some())
+            })
+            .is_some()
+    }
+
     /// Steals a previously stashed error with the given `Span` and
     /// [`StashKey`] as the key, modifies it, and emits it. Returns `None` if
     /// no matching diagnostic is found. Panics if the found diagnostic's level
@@ -1251,6 +1270,17 @@ impl DiagCtxt {
         self.create_err(err).emit()
     }
 
+    /// See [`DiagCtxt::stash_diagnostic`] for details.
+    #[track_caller]
+    pub fn stash_err<'a>(
+        &'a self,
+        span: Span,
+        key: StashKey,
+        err: impl Diagnostic<'a>,
+    ) -> ErrorGuaranteed {
+        self.create_err(err).stash(span, key).unwrap()
+    }
+
     /// Ensures that an error is printed. See `Level::DelayedBug`.
     //
     // No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
@@ -20,7 +20,7 @@ use rustc_ast::{
     PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax,
 };
 use rustc_ast_pretty::pprust;
-use rustc_errors::{Applicability, Diag, PResult};
+use rustc_errors::{Applicability, Diag, PResult, StashKey};
 use rustc_session::errors::ExprParenthesesNeeded;
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident};
@@ -351,7 +351,7 @@ impl<'a> Parser<'a> {
         &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;
@@ -429,11 +429,16 @@ impl<'a> Parser<'a> {
                 // Check that `parse_expr_assoc_with` didn't eat a rhs.
                 let is_method_call = false && non_assoc_span == expr.span;
 
-                return Some(self.dcx().emit_err(UnexpectedExpressionInPattern {
-                    span: expr.span,
-                    is_bound,
-                    is_method_call,
-                }));
+                let span = expr.span;
+
+                return Some((
+                    self.dcx().stash_err(
+                        span,
+                        StashKey::ExprInPat,
+                        UnexpectedExpressionInPattern { span, is_bound, is_method_call },
+                    ),
+                    span,
+                ));
             }
         }
 
@@ -550,7 +555,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),
                 }
             }
@@ -584,7 +589,7 @@ impl<'a> Parser<'a> {
             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),
+                        Some((guar, sp)) => self.mk_expr_err(sp, guar),
                         None => begin,
                     };
 
@@ -762,7 +767,25 @@ impl<'a> Parser<'a> {
 
         Ok(match self.maybe_recover_trailing_expr(open_paren.to(self.prev_token.span), false) {
             None => pat,
-            Some(guar) => PatKind::Err(guar)
+            Some((guar, _)) => {
+                // We just recovered a bigger expression, so cancel its children
+                // (e.g. `(1 + 2) * 3`, cancel “`1 + 2` is not a pattern”).
+                match pat {
+                    PatKind::Paren(pat) => {
+                        self.dcx().steal_err(pat.span, StashKey::ExprInPat, guar);
+                    }
+
+                    PatKind::Tuple(fields) => {
+                        for pat in fields {
+                            self.dcx().steal_err(pat.span, StashKey::ExprInPat, guar);
+                        }
+                    }
+
+                    _ => unreachable!(),
+                }
+
+                PatKind::Err(guar)
+            }
         })
     }
 
@@ -1014,7 +1037,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,
         })
     }
@@ -1083,7 +1106,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/half-open-range-patterns/range_pat_interactions1.stderr b/tests/ui/half-open-range-patterns/range_pat_interactions1.stderr
@@ -1,9 +1,3 @@
-error: expected a pattern range bound, found an expression
-  --> $DIR/range_pat_interactions1.rs:19:16
-   |
-LL |             0..5+1 => errors_only.push(x),
-   |                ^^^ arbitrary expressions are not allowed in patterns
-
 error[E0408]: variable `n` is not bound in all patterns
   --> $DIR/range_pat_interactions1.rs:10:25
    |
@@ -99,6 +93,12 @@ LL |             y @ ..-7 => assert_eq!(y, -8),
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = help: use an inclusive range pattern, like N..=M
 
+error: expected a pattern range bound, found an expression
+  --> $DIR/range_pat_interactions1.rs:19:16
+   |
+LL |             0..5+1 => errors_only.push(x),
+   |                ^^^ arbitrary expressions are not allowed in patterns
+
 error: aborting due to 10 previous errors
 
 Some errors have detailed explanations: E0408, E0658.
diff --git 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
    |
@@ -70,6 +64,12 @@ LL |             y @ ..-7 => assert_eq!(y, -8),
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = help: use an inclusive range pattern, like N..=M
 
+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: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/parser/bad-name.stderr b/tests/ui/parser/bad-name.stderr
@@ -4,17 +4,17 @@ error: field expressions cannot have generic arguments
 LL |   let x.y::<isize>.z foo;
    |            ^^^^^^^
 
-error: expected a pattern, found an expression
-  --> $DIR/bad-name.rs:4: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:4:22
    |
 LL |   let x.y::<isize>.z foo;
    |                      ^^^ expected one of 9 possible tokens
 
+error: expected a pattern, found an expression
+  --> $DIR/bad-name.rs:4:7
+   |
+LL |   let x.y::<isize>.z foo;
+   |       ^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/parser/pat-lt-bracket-5.stderr b/tests/ui/parser/pat-lt-bracket-5.stderr
@@ -1,15 +1,15 @@
-error: expected a pattern, found an expression
-  --> $DIR/pat-lt-bracket-5.rs:2:9
-   |
-LL |     let v[0] = v[1];
-   |         ^^^^ arbitrary expressions are not allowed in patterns
-
 error[E0425]: cannot find value `v` in this scope
   --> $DIR/pat-lt-bracket-5.rs:2:16
    |
 LL |     let v[0] = v[1];
    |                ^ not found in this scope
 
+error: expected a pattern, found an expression
+  --> $DIR/pat-lt-bracket-5.rs:2:9
+   |
+LL |     let v[0] = v[1];
+   |         ^^^^ arbitrary expressions are not allowed in patterns
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/parser/pat-lt-bracket-6.stderr b/tests/ui/parser/pat-lt-bracket-6.stderr
@@ -1,9 +1,3 @@
-error: expected a pattern, found an expression
-  --> $DIR/pat-lt-bracket-6.rs:5:15
-   |
-LL |     let Test(&desc[..]) = x;
-   |               ^^^^^^^^ arbitrary expressions are not allowed in patterns
-
 error[E0308]: mismatched types
   --> $DIR/pat-lt-bracket-6.rs:10:30
    |
@@ -24,6 +18,12 @@ help: use `_` to explicitly ignore each field
 LL |     let Test(&desc[..], _) = x;
    |                       +++
 
+error: expected a pattern, found an expression
+  --> $DIR/pat-lt-bracket-6.rs:5:15
+   |
+LL |     let Test(&desc[..]) = x;
+   |               ^^^^^^^^ arbitrary expressions are not allowed in patterns
+
 error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0023, E0308.
diff --git a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr
@@ -1,9 +1,3 @@
-error: expected a pattern, found an expression
-  --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:31
-   |
-LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
-   |                               ^^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
-
 error[E0412]: cannot find type `T` in this scope
   --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:55
    |
@@ -30,6 +24,12 @@ error[E0533]: expected unit struct, unit variant or constant, found associated f
 LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a unit struct, unit variant or constant
 
+error: expected a pattern, found an expression
+  --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:31
+   |
+LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
+   |                               ^^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns
+
 error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0109, E0412, E0533.
