mbe: Factor out a helper to parse and only keep spans on success

`try_match_macro` does a careful dance of saving the parser's spans,
restoring them on failure, and merging them on success.

Wrap this in a function, so we can easily reuse it.

Author: joshtriplett

compiler/rustc_expand/src/mbe/macro_parser.rs

@@ -73,6 +73,7 @@
 use std::borrow::Cow;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::fmt::Display;
+use std::mem;
 use std::rc::Rc;
 
 pub(crate) use NamedMatch::*;
@@ -689,6 +690,36 @@ impl TtParser {
         }
     }
 
+    /// Match the token stream from `parser` against `matcher`; only keep parsed spans on success.
+    pub(super) fn parse_tt_preserve_spans<'matcher, T: Tracker<'matcher>>(
+        &mut self,
+        parser: &mut Cow<'_, Parser<'_>>,
+        matcher: &'matcher [MatcherLoc],
+        track: &mut T,
+    ) -> NamedParseResult<T::Failure> {
+        // Take a snapshot of the state of pre-expansion gating at this point.
+        // This is used so that if a matcher is not `Success(..)`ful,
+        // then the spans which became gated when parsing the unsuccessful matcher
+        // are not recorded. On the first `Success(..)`ful matcher, the spans are merged.
+        let mut gated_spans_snapshot = mem::take(&mut *parser.psess.gated_spans.spans.borrow_mut());
+        let result = self.parse_tt(parser, matcher, track);
+        track.after_arm(&result);
+        match &result {
+            Success(_) => {
+                // The matcher was `Success(..)`ful.
+                // Merge the gated spans from parsing the matcher with the preexisting ones.
+                parser.psess.gated_spans.merge(gated_spans_snapshot);
+            }
+            Failure(_) => {
+                // The matcher failed.
+                // Restore to the state before snapshotting and maybe try again.
+                mem::swap(&mut gated_spans_snapshot, &mut parser.psess.gated_spans.spans.borrow_mut());
+            }
+            _ => {}
+        }
+        result
+    }
+
     fn ambiguity_error<F>(
         &self,
         matcher: &[MatcherLoc],

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::sync::Arc;
-use std::{mem, slice};
+use std::slice;
 
 use ast::token::IdentIsRaw;
 use rustc_ast::token::NtPatKind::*;
@@ -318,24 +318,9 @@ pub(super) fn try_match_macro<'matcher, T: Tracker<'matcher>>(
     let mut tt_parser = TtParser::new(name);
     for (i, rule) in rules.iter().enumerate() {
         let _tracing_span = trace_span!("Matching arm", %i);
-
-        // Take a snapshot of the state of pre-expansion gating at this point.
-        // This is used so that if a matcher is not `Success(..)`ful,
-        // then the spans which became gated when parsing the unsuccessful matcher
-        // are not recorded. On the first `Success(..)`ful matcher, the spans are merged.
-        let mut gated_spans_snapshot = mem::take(&mut *psess.gated_spans.spans.borrow_mut());
-
-        let result = tt_parser.parse_tt(&mut Cow::Borrowed(&parser), &rule.lhs, track);
-
-        track.after_arm(&result);
-
-        match result {
+        match tt_parser.parse_tt_preserve_spans(&mut Cow::Borrowed(&parser), &rule.lhs, track) {
             Success(named_matches) => {
                 debug!("Parsed arm successfully");
-                // The matcher was `Success(..)`ful.
-                // Merge the gated spans from parsing the matcher with the preexisting ones.
-                psess.gated_spans.merge(gated_spans_snapshot);
-
                 return Ok((i, rule, named_matches));
             }
             Failure(_) => {
@@ -353,10 +338,6 @@ pub(super) fn try_match_macro<'matcher, T: Tracker<'matcher>>(
                 return Err(CanRetry::No(guarantee));
             }
         }
-
-        // The matcher was not `Success(..)`ful.
-        // Restore to the state before snapshotting and maybe try again.
-        mem::swap(&mut gated_spans_snapshot, &mut psess.gated_spans.spans.borrow_mut());
     }
 
     Err(CanRetry::Yes)