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_errors/src/lib.rs

@@ -833,6 +833,7 @@ impl DiagCtxt {
         *fulfilled_expectations = Default::default();
     }
 
+    #[inline]
     pub fn handle<'a>(&'a self) -> DiagCtxtHandle<'a> {
         DiagCtxtHandle { dcx: self, tainted_with_errors: None }
     }

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -70,6 +70,7 @@ struct TranscrCtx<'psess, 'itp> {
 
 impl<'psess> TranscrCtx<'psess, '_> {
     /// Span marked with the correct expansion and transparency.
+    #[inline(always)]
     fn visited_dspan(&mut self, dspan: DelimSpan) -> Span {
         let mut span = dspan.entire();
         self.marker.mark_span(&mut span);
@@ -86,6 +87,7 @@ struct Marker {
 
 impl Marker {
     /// Mark a span with the stored expansion ID and transparency.
+    #[inline(always)]
     fn mark_span(&mut self, span: &mut Span) {
         // `apply_mark` is a relatively expensive operation, both due to taking hygiene lock, and
         // by itself. All tokens in a macro body typically have the same syntactic context, unless
@@ -113,6 +115,7 @@ enum FrameKind {
 }
 
 impl<'a> Frame<'a> {
+    #[inline(always)]
     fn new_delimited(src: &'a mbe::Delimited, span: DelimSpan, spacing: DelimSpacing) -> Frame<'a> {
         Frame {
             tts: &src.tts,
@@ -121,6 +124,7 @@ impl<'a> Frame<'a> {
         }
     }
 
+    #[inline(always)]
     fn new_sequence(
         src: &'a mbe::SequenceRepetition,
         sep: Option<Token>,
@@ -133,6 +137,7 @@ impl<'a> Frame<'a> {
 impl<'a> Iterator for Frame<'a> {
     type Item = &'a mbe::TokenTree;
 
+    #[inline(always)]
     fn next(&mut self) -> Option<&'a mbe::TokenTree> {
         let res = self.tts.get(self.idx);
         self.idx += 1;
@@ -289,6 +294,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 +363,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 +499,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 +510,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 +545,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 +626,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<'_>],
@@ -682,6 +692,7 @@ fn maybe_use_metavar_location(
 /// See the definition of `repeats` in the `transcribe` function. `repeats` is used to descend
 /// into the right place in nested matchers. If we attempt to descend too far, the macro writer has
 /// made a mistake, and we return `None`.
+#[inline(always)]
 fn lookup_cur_matched<'a>(
     ident: MacroRulesNormalizedIdent,
     interpolations: &'a FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
@@ -722,6 +733,7 @@ impl LockstepIterSize {
     /// - `Unconstrained` is compatible with everything.
     /// - `Contradiction` is incompatible with everything.
     /// - `Constraint(len)` is only compatible with other constraints of the same length.
+    #[inline(always)]
     fn with(self, other: LockstepIterSize) -> LockstepIterSize {
         match self {
             LockstepIterSize::Unconstrained => other,
@@ -759,6 +771,7 @@ impl LockstepIterSize {
 /// declared at depths which weren't equal or there was a compiler bug. For example, if we have 3 repetitions of
 /// the outer sequence and 4 repetitions of the inner sequence for `x`, we should have the same for
 /// `y`; otherwise, we can't transcribe them both at the given depth.
+#[inline(always)]
 fn lockstep_iter_size(
     tree: &mbe::TokenTree,
     interpolations: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
@@ -808,12 +821,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).
@@ -869,6 +883,7 @@ fn count_repetitions<'dx>(
 }
 
 /// Returns a `NamedMatch` item declared on the LHS given an arbitrary [Ident]
+#[inline(always)]
 fn matched_from_ident<'ctx, 'interp, 'rslt>(
     dcx: DiagCtxtHandle<'ctx>,
     ident: Ident,
@@ -900,6 +915,7 @@ fn out_of_bounds_err<'a>(dcx: DiagCtxtHandle<'a>, max: usize, span: Span, ty: &s
 }
 
 /// Extracts an metavariable symbol that can be an identifier, a token tree or a literal.
+#[inline(always)]
 fn extract_symbol_from_pnr<'a>(
     dcx: DiagCtxtHandle<'a>,
     pnr: &ParseNtResult,

compiler/rustc_session/src/parse.rs

@@ -334,6 +334,7 @@ impl ParseSess {
         self.proc_macro_quoted_spans.iter_enumerated()
     }
 
+    #[inline]
     pub fn dcx(&self) -> DiagCtxtHandle<'_> {
         self.dcx.handle()
     }