Preserve leading vert when pretty-printing patterns

Fixes #76182

Previously, we did not preserve the precense of a leading vert ('|')
when parsing a pattern. This lead to an instance of #43081 when invoking
a proc-macro, since the pretty-printed tokens would be missing the '|'
present in the captured tokens.

Author: Aaron1011

compiler/rustc_ast/src/ast.rs

@@ -550,6 +550,8 @@ pub struct Pat {
     pub id: NodeId,
     pub kind: PatKind,
     pub span: Span,
+    /// Whether or not this pattern starts with a leading `|`
+    pub leading_vert: bool,
     pub tokens: Option<TokenStream>,
 }
 
@@ -2140,6 +2142,7 @@ impl Param {
                 id: DUMMY_NODE_ID,
                 kind: PatKind::Ident(BindingMode::ByValue(mutbl), eself_ident, None),
                 span,
+                leading_vert: false,
                 tokens: None,
             }),
             span,

compiler/rustc_ast/src/mut_visit.rs

@@ -1054,7 +1054,7 @@ pub fn noop_flat_map_foreign_item<T: MutVisitor>(
 }
 
 pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
-    let Pat { id, kind, span, tokens: _ } = pat.deref_mut();
+    let Pat { id, kind, span, leading_vert: _, tokens: _ } = pat.deref_mut();
     vis.visit_id(id);
     match kind {
         PatKind::Wild | PatKind::Rest => {}

compiler/rustc_ast_pretty/src/pprust.rs

@@ -2302,6 +2302,11 @@ impl<'a> State<'a> {
     crate fn print_pat(&mut self, pat: &ast::Pat) {
         self.maybe_print_comment(pat.span.lo());
         self.ann.pre(self, AnnNode::Pat(pat));
+
+        if pat.leading_vert {
+            self.s.word_space("|");
+        }
+
         /* Pat isn't normalized, but the beauty of it
         is that it doesn't matter */
         match pat.kind {

compiler/rustc_expand/src/base.rs

@@ -551,6 +551,7 @@ impl MacResult for MacEager {
                     id: ast::DUMMY_NODE_ID,
                     span: e.span,
                     kind: PatKind::Lit(e),
+                    leading_vert: false,
                     tokens: None,
                 }));
             }
@@ -598,7 +599,13 @@ impl DummyResult {
 
     /// A plain dummy pattern.
     pub fn raw_pat(sp: Span) -> ast::Pat {
-        ast::Pat { id: ast::DUMMY_NODE_ID, kind: PatKind::Wild, span: sp, tokens: None }
+        ast::Pat {
+            id: ast::DUMMY_NODE_ID,
+            kind: PatKind::Wild,
+            span: sp,
+            leading_vert: false,
+            tokens: None,
+        }
     }
 
     /// A plain dummy type.

compiler/rustc_expand/src/build.rs

@@ -392,7 +392,7 @@ impl<'a> ExtCtxt<'a> {
     }
 
     pub fn pat(&self, span: Span, kind: PatKind) -> P<ast::Pat> {
-        P(ast::Pat { id: ast::DUMMY_NODE_ID, kind, span, tokens: None })
+        P(ast::Pat { id: ast::DUMMY_NODE_ID, kind, span, leading_vert: false, tokens: None })
     }
     pub fn pat_wild(&self, span: Span) -> P<ast::Pat> {
         self.pat(span, PatKind::Wild)

compiler/rustc_expand/src/placeholders.rs

@@ -38,8 +38,15 @@ pub fn placeholder(
         })
     };
     let ty = || P(ast::Ty { id, kind: ast::TyKind::MacCall(mac_placeholder()), span });
-    let pat =
-        || P(ast::Pat { id, kind: ast::PatKind::MacCall(mac_placeholder()), span, tokens: None });
+    let pat = || {
+        P(ast::Pat {
+            id,
+            kind: ast::PatKind::MacCall(mac_placeholder()),
+            span,
+            leading_vert: false,
+            tokens: None,
+        })
+    };
 
     match kind {
         AstFragmentKind::Expr => AstFragment::Expr(expr_placeholder()),
@@ -86,6 +93,7 @@ pub fn placeholder(
             id,
             span,
             kind: ast::PatKind::MacCall(mac_placeholder()),
+            leading_vert: false,
             tokens: None,
         })),
         AstFragmentKind::Ty => {

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -26,6 +26,7 @@ pub(super) fn dummy_arg(ident: Ident) -> Param {
         id: ast::DUMMY_NODE_ID,
         kind: PatKind::Ident(BindingMode::ByValue(Mutability::Not), ident, None),
         span: ident.span,
+        leading_vert: false,
         tokens: None,
     });
     let ty = Ty { kind: TyKind::Err, span: ident.span, id: ast::DUMMY_NODE_ID };
@@ -88,6 +89,7 @@ impl RecoverQPath for Pat {
             span: path.span,
             kind: PatKind::Path(qself, path),
             id: ast::DUMMY_NODE_ID,
+            leading_vert: false,
             tokens: None,
         }
     }
@@ -1532,8 +1534,13 @@ impl<'a> Parser<'a> {
         .emit();
 
         // Pretend the pattern is `_`, to avoid duplicate errors from AST validation.
-        let pat =
-            P(Pat { kind: PatKind::Wild, span: pat.span, id: ast::DUMMY_NODE_ID, tokens: None });
+        let pat = P(Pat {
+            kind: PatKind::Wild,
+            span: pat.span,
+            id: ast::DUMMY_NODE_ID,
+            leading_vert: false,
+            tokens: None,
+        });
         Ok((pat, ty))
     }
 

compiler/rustc_parse/src/parser/pat.rs

@@ -45,11 +45,12 @@ impl<'a> Parser<'a> {
     /// Corresponds to `top_pat` in RFC 2535 and allows or-pattern at the top level.
     pub(super) fn parse_top_pat(&mut self, gate_or: GateOr) -> PResult<'a, P<Pat>> {
         // Allow a '|' before the pats (RFCs 1925, 2530, and 2535).
-        let gated_leading_vert = self.eat_or_separator(None) && gate_or == GateOr::Yes;
+        let leading_vert = self.eat_or_separator(None);
+        let gated_leading_vert = leading_vert && gate_or == GateOr::Yes;
         let leading_vert_span = self.prev_token.span;
 
         // Parse the possibly-or-pattern.
-        let pat = self.parse_pat_with_or(None, gate_or, RecoverComma::Yes)?;
+        let mut pat = self.parse_pat_with_or(None, gate_or, RecoverComma::Yes)?;
 
         // If we parsed a leading `|` which should be gated,
         // and no other gated or-pattern has been parsed thus far,
@@ -58,6 +59,7 @@ impl<'a> Parser<'a> {
         if gated_leading_vert && self.sess.gated_spans.is_ungated(sym::or_patterns) {
             self.sess.gated_spans.gate(sym::or_patterns, leading_vert_span);
         }
+        pat.leading_vert = leading_vert;
 
         Ok(pat)
     }
@@ -1007,6 +1009,6 @@ impl<'a> Parser<'a> {
     }
 
     fn mk_pat(&self, span: Span, kind: PatKind) -> P<Pat> {
-        P(Pat { kind, span, id: ast::DUMMY_NODE_ID, tokens: None })
+        P(Pat { kind, span, id: ast::DUMMY_NODE_ID, leading_vert: false, tokens: None })
     }
 }

src/test/ui-fulldeps/pprust-expr-roundtrip.rs

@@ -164,6 +164,7 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
                     id: DUMMY_NODE_ID,
                     kind: PatKind::Wild,
                     span: DUMMY_SP,
+                    leading_vert: false,
                     tokens: None,
                 });
                 iter_exprs(depth - 1, &mut |e| g(ExprKind::Let(pat.clone(), e)))

src/test/ui/proc-macro/issue-76182-leading-vert-pat.rs

@@ -0,0 +1,16 @@
+// check-pass
+// aux-build:test-macros.rs
+// compile-flags: -Z span-debug
+//
+// Regression test for issue #76182
+// Tests that we properly handle patterns with a leading vert
+
+#![no_std] // Don't load unnecessary hygiene information from std
+extern crate std;
+
+extern crate test_macros;
+
+#[test_macros::print_attr]
+fn main() {
+    match () { | () => () }
+}