Rollup merge of #137872 - estebank:extra-vert, r=compiler-errors

Include whitespace in "remove |" suggestion and make it hidden

Tweak error rendering of patterns with an extra `|` on either end.

Built on #137409. Only last commit is relevant.

? ``@compiler-errors``

Author: Kobzol

compiler/rustc_errors/src/diagnostic.rs

@@ -1113,7 +1113,7 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
             .map(|snippet| {
                 debug_assert!(
                     !(sp.is_empty() && snippet.is_empty()),
-                    "Span must not be empty and have no suggestion"
+                    "Span `{sp:?}` must not be empty and have no suggestion"
                 );
                 Substitution { parts: vec![SubstitutionPart { snippet, span: sp }] }
             })

compiler/rustc_parse/messages.ftl

@@ -862,8 +862,8 @@ parse_too_many_hashes = too many `#` symbols: raw strings may be delimited by up
 
 parse_too_short_hex_escape = numeric character escape is too short
 
-parse_trailing_vert_not_allowed = a trailing `|` is not allowed in an or-pattern
-    .suggestion = remove the `{$token}`
+parse_trailing_vert_not_allowed = a trailing `{$token}` is not allowed in an or-pattern
+parse_trailing_vert_not_allowed_suggestion = remove the `{$token}`
 
 parse_trait_alias_cannot_be_auto = trait aliases cannot be `auto`
 parse_trait_alias_cannot_be_const = trait aliases cannot be `const`

compiler/rustc_parse/src/errors.rs

@@ -2661,7 +2661,7 @@ pub(crate) enum TopLevelOrPatternNotAllowedSugg {
         parse_sugg_remove_leading_vert_in_pattern,
         code = "",
         applicability = "machine-applicable",
-        style = "verbose"
+        style = "tool-only"
     )]
     RemoveLeadingVert {
         #[primary_span]
@@ -2694,12 +2694,25 @@ pub(crate) struct UnexpectedVertVertInPattern {
     pub start: Option<Span>,
 }
 
+#[derive(Subdiagnostic)]
+#[suggestion(
+    parse_trailing_vert_not_allowed,
+    code = "",
+    applicability = "machine-applicable",
+    style = "tool-only"
+)]
+pub(crate) struct TrailingVertSuggestion {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_trailing_vert_not_allowed)]
 pub(crate) struct TrailingVertNotAllowed {
     #[primary_span]
-    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
     pub span: Span,
+    #[subdiagnostic]
+    pub suggestion: TrailingVertSuggestion,
     #[label(parse_label_while_parsing_or_pattern_here)]
     pub start: Option<Span>,
     pub token: Token,

compiler/rustc_parse/src/parser/pat.rs

@@ -24,10 +24,10 @@ use crate::errors::{
     GenericArgsInPatRequireTurbofishSyntax, InclusiveRangeExtraEquals, InclusiveRangeMatchArrow,
     InclusiveRangeNoEnd, InvalidMutInPattern, ParenRangeSuggestion, PatternOnWrongSideOfAt,
     RemoveLet, RepeatedMutInPattern, SwitchRefBoxOrder, TopLevelOrPatternNotAllowed,
-    TopLevelOrPatternNotAllowedSugg, TrailingVertNotAllowed, UnexpectedExpressionInPattern,
-    UnexpectedExpressionInPatternSugg, UnexpectedLifetimeInPattern, UnexpectedParenInRangePat,
-    UnexpectedParenInRangePatSugg, UnexpectedVertVertBeforeFunctionParam,
-    UnexpectedVertVertInPattern, WrapInParens,
+    TopLevelOrPatternNotAllowedSugg, TrailingVertNotAllowed, TrailingVertSuggestion,
+    UnexpectedExpressionInPattern, UnexpectedExpressionInPatternSugg, UnexpectedLifetimeInPattern,
+    UnexpectedParenInRangePat, UnexpectedParenInRangePatSugg,
+    UnexpectedVertVertBeforeFunctionParam, UnexpectedVertVertInPattern, WrapInParens,
 };
 use crate::parser::expr::{DestructuredFloat, could_be_unclosed_char_literal};
 use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
@@ -267,10 +267,9 @@ impl<'a> Parser<'a> {
 
         if let PatKind::Or(pats) = &pat.kind {
             let span = pat.span;
-            let sub = if pats.len() == 1 {
-                Some(TopLevelOrPatternNotAllowedSugg::RemoveLeadingVert {
-                    span: span.with_hi(span.lo() + BytePos(1)),
-                })
+            let sub = if let [_] = &pats[..] {
+                let span = span.with_hi(span.lo() + BytePos(1));
+                Some(TopLevelOrPatternNotAllowedSugg::RemoveLeadingVert { span })
             } else {
                 Some(TopLevelOrPatternNotAllowedSugg::WrapInParens {
                     span,
@@ -362,6 +361,9 @@ impl<'a> Parser<'a> {
                 self.dcx().emit_err(TrailingVertNotAllowed {
                     span: self.token.span,
                     start: lo,
+                    suggestion: TrailingVertSuggestion {
+                        span: self.prev_token.span.shrink_to_hi().with_hi(self.token.span.hi()),
+                    },
                     token: self.token,
                     note_double_vert: self.token.kind == token::OrOr,
                 });

tests/ui/or-patterns/issue-64879-trailing-before-guard.fixed

@@ -0,0 +1,18 @@
+// In this regression test we check that a trailing `|` in an or-pattern just
+// before the `if` token of a `match` guard will receive parser recovery with
+// an appropriate error message.
+//@ run-rustfix
+#![allow(dead_code)]
+
+enum E { A, B }
+
+fn main() {
+    match E::A {
+        E::A |
+        E::B //~ ERROR a trailing `|` is not allowed in an or-pattern
+        if true => {
+            let _recovery_witness: i32 = 0i32; //~ ERROR mismatched types
+        }
+        _ => {}
+    }
+}

tests/ui/or-patterns/issue-64879-trailing-before-guard.rs

@@ -1,6 +1,8 @@
 // In this regression test we check that a trailing `|` in an or-pattern just
 // before the `if` token of a `match` guard will receive parser recovery with
 // an appropriate error message.
+//@ run-rustfix
+#![allow(dead_code)]
 
 enum E { A, B }
 
@@ -9,7 +11,8 @@ fn main() {
         E::A |
         E::B | //~ ERROR a trailing `|` is not allowed in an or-pattern
         if true => {
-            let recovery_witness: bool = 0; //~ ERROR mismatched types
+            let _recovery_witness: i32 = 0u32; //~ ERROR mismatched types
         }
+        _ => {}
     }
 }

tests/ui/or-patterns/issue-64879-trailing-before-guard.stderr

@@ -1,24 +1,24 @@
 error: a trailing `|` is not allowed in an or-pattern
-  --> $DIR/issue-64879-trailing-before-guard.rs:10:14
+  --> $DIR/issue-64879-trailing-before-guard.rs:12:14
    |
 LL |         E::A |
    |         ---- while parsing this or-pattern starting here
 LL |         E::B |
    |              ^
+
+error[E0308]: mismatched types
+  --> $DIR/issue-64879-trailing-before-guard.rs:14:42
    |
-help: remove the `|`
+LL |             let _recovery_witness: i32 = 0u32;
+   |                                    ---   ^^^^ expected `i32`, found `u32`
+   |                                    |
+   |                                    expected due to this
    |
-LL -         E::B |
-LL +         E::B
+help: change the type of the numeric literal from `u32` to `i32`
    |
-
-error[E0308]: mismatched types
-  --> $DIR/issue-64879-trailing-before-guard.rs:12:42
+LL -             let _recovery_witness: i32 = 0u32;
+LL +             let _recovery_witness: i32 = 0i32;
    |
-LL |             let recovery_witness: bool = 0;
-   |                                   ----   ^ expected `bool`, found integer
-   |                                   |
-   |                                   expected due to this
 
 error: aborting due to 2 previous errors
 

tests/ui/or-patterns/remove-leading-vert.fixed

@@ -23,26 +23,26 @@ fn leading() {
 
 #[cfg(false)]
 fn trailing() {
-    let ( A  ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let (a ,): (E,); //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let ( A | B  ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let [ A | B  ]: [E; 1]; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let S { f: B  }; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let ( A | B  ): E; //~ ERROR unexpected token `||` in pattern
+    let ( A ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let (a,): (E,); //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let ( A | B ): E; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let [ A | B ]: [E; 1]; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let S { f: B }; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let ( A | B ): E; //~ ERROR unexpected token `||` in pattern
     //~^ ERROR a trailing `|` is not allowed in an or-pattern
     match A {
-        A  => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
-        A  => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
-        A | B  => {} //~ ERROR unexpected token `||` in pattern
+        A => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
+        A => {} //~ ERROR a trailing `||` is not allowed in an or-pattern
+        A | B => {} //~ ERROR unexpected token `||` in pattern
         //~^ ERROR a trailing `|` is not allowed in an or-pattern
-        | A | B  => {}
+        | A | B => {}
         //~^ ERROR a trailing `|` is not allowed in an or-pattern
     }
 
     // These test trailing-vert in `let` bindings, but they also test that we don't emit a
     // duplicate suggestion that would confuse rustfix.
 
-    let a  : u8 = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let a  = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
-    let a  ; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let a : u8 = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let a = 0; //~ ERROR a trailing `|` is not allowed in an or-pattern
+    let a ; //~ ERROR a trailing `|` is not allowed in an or-pattern
 }

tests/ui/or-patterns/remove-leading-vert.rs

@@ -32,7 +32,7 @@ fn trailing() {
     //~^ ERROR a trailing `|` is not allowed in an or-pattern
     match A {
         A | => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
-        A || => {} //~ ERROR a trailing `|` is not allowed in an or-pattern
+        A || => {} //~ ERROR a trailing `||` is not allowed in an or-pattern
         A || B | => {} //~ ERROR unexpected token `||` in pattern
         //~^ ERROR a trailing `|` is not allowed in an or-pattern
         | A | B | => {}