Auto merge of #142815 - tgross35:transcribe-perf, r=<try>

mbe: Inline functions in `transcribe` that are only called once

[#142713] did some refactoring of macro expansion, which seems to have had an effect on performance. The only change was to split large functions into smaller ones, so mark some functions that are only called once `#[inline]` to make codegen more similar.

[#142713]: https://www.github.com/rust-lang/rust/pull/142713

Author: rust-bors[bot]

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -27,14 +27,6 @@ use crate::mbe::{self, KleeneOp, MetaVarExpr};
 
 /// Context needed to perform transcription of metavariable expressions.
 struct TranscrCtx<'psess, 'itp> {
-    psess: &'psess ParseSess,
-
-    /// Map from metavars to matched tokens
-    interp: &'itp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
-
-    /// Allow marking spans.
-    marker: Marker,
-
     /// The stack of things yet to be completely expanded.
     ///
     /// We descend into the RHS (`src`), expanding things as we go. This stack contains the things
@@ -66,6 +58,14 @@ struct TranscrCtx<'psess, 'itp> {
     /// The in-progress `result` lives at the top of this stack. Each entered `TokenTree` adds a
     /// new entry.
     result_stack: Vec<Vec<TokenTree>>,
+
+    /// Allow marking spans.
+    marker: Marker,
+
+    psess: &'psess ParseSess,
+
+    /// Map from metavars to matched tokens
+    interp: &'itp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
 }
 
 impl<'psess> TranscrCtx<'psess, '_> {
@@ -174,17 +174,17 @@ pub(super) fn transcribe<'a>(
     }
 
     let mut tscx = TranscrCtx {
-        psess,
-        interp,
-        marker: Marker { expand_id, transparency, cache: Default::default() },
-        repeats: Vec::new(),
         stack: smallvec![Frame::new_delimited(
             src,
             src_span,
             DelimSpacing::new(Spacing::Alone, Spacing::Alone)
         )],
+        repeats: Vec::new(),
         result: Vec::new(),
         result_stack: Vec::new(),
+        marker: Marker { expand_id, transparency, cache: Default::default() },
+        psess,
+        interp,
     };
 
     loop {
@@ -289,6 +289,7 @@ pub(super) fn transcribe<'a>(
 }
 
 /// Turn `$(...)*` sequences into tokens.
+#[inline(always)] // called once
 fn transcribe_sequence<'tx, 'itp>(
     tscx: &mut TranscrCtx<'tx, 'itp>,
     seq: &mbe::TokenTree,
@@ -357,6 +358,7 @@ fn transcribe_sequence<'tx, 'itp>(
 /// producing "xyz", which is bad because it effectively merges tokens.
 /// `Spacing::Alone` is the safer option. Fortunately, `space_between` will avoid
 /// some of the unnecessary whitespace.
+#[inline(always)] // called once
 fn transcribe_metavar<'tx>(
     tscx: &mut TranscrCtx<'tx, '_>,
     mut sp: Span,
@@ -492,6 +494,7 @@ fn transcribe_metavar<'tx>(
 }
 
 /// Turn `${expr(...)}` metavariable expressionss into tokens.
+#[inline(always)] // called once
 fn transcribe_metavar_expr<'tx>(
     tscx: &mut TranscrCtx<'tx, '_>,
     dspan: DelimSpan,
@@ -502,7 +505,7 @@ fn transcribe_metavar_expr<'tx>(
         MetaVarExpr::Concat(ref elements) => metavar_expr_concat(tscx, dspan, elements)?,
         MetaVarExpr::Count(original_ident, depth) => {
             let matched = matched_from_ident(dcx, original_ident, tscx.interp)?;
-            let count = count_repetitions(dcx, depth, matched, &tscx.repeats, &dspan)?;
+            let count = count_repetitions(dcx, depth, matched, &tscx.repeats, dspan)?;
             TokenTree::token_alone(
                 TokenKind::lit(token::Integer, sym::integer(count), None),
                 tscx.visited_dspan(dspan),
@@ -537,6 +540,7 @@ fn transcribe_metavar_expr<'tx>(
 }
 
 /// Handle the `${concat(...)}` metavariable expression.
+#[inline(always)] // called once
 fn metavar_expr_concat<'tx>(
     tscx: &mut TranscrCtx<'tx, '_>,
     dspan: DelimSpan,
@@ -617,6 +621,7 @@ fn metavar_expr_concat<'tx>(
 ///   These are typically used for passing larger amounts of code, and tokens in that code usually
 ///   combine with each other and not with tokens outside of the sequence.
 /// - The metavariable span comes from a different crate, then we prefer the more local span.
+#[inline(always)] // called once
 fn maybe_use_metavar_location(
     psess: &ParseSess,
     stack: &[Frame<'_>],
@@ -808,12 +813,13 @@ fn lockstep_iter_size(
 /// * `[ $( ${count(foo, 0)} ),* ]` will be the same as `[ $( ${count(foo)} ),* ]`
 /// * `[ $( ${count(foo, 1)} ),* ]` will return an error because `${count(foo, 1)}` is
 ///   declared inside a single repetition and the index `1` implies two nested repetitions.
+#[inline(always)] // called once
 fn count_repetitions<'dx>(
     dcx: DiagCtxtHandle<'dx>,
     depth_user: usize,
     mut matched: &NamedMatch,
     repeats: &[(usize, usize)],
-    sp: &DelimSpan,
+    sp: DelimSpan,
 ) -> PResult<'dx, usize> {
     // Recursively count the number of matches in `matched` at given depth
     // (or at the top-level of `matched` if no depth is given).