From ab06e2749d931efdd014c346f9a1caa33029711c Mon Sep 17 00:00:00 2001
From: Makro <mnlkroiss@gmail.com>
Date: Sat, 1 Aug 2026 10:02:44 +0000
Subject: [PATCH] perf: mbe: compile rule RHS into a pre-flattened
 transcription template

Transcription walked the RHS tree token by token on every expansion:
one dispatch, span mark, and buffer push per literal token, plus a
metavar normalization per occurrence. The tree is now lowered once per
rule (lazily, on first expansion) into a template whose runs of literal
tokens, including whole literal delimited groups, are pre-encoded as
flat entries. Transcription copies each run into the output buffer,
rebases depths and match indices, and marks the copied spans in place.
Metavar occurrences carry their normalization precomputed, and the
sequence lockstep check walks a precollected list of the metavars in
the sequence subtree instead of re-walking the tree.

clap_derive check -0.52%, html5ever check -0.46%, syn check -0.27%,
tt-muncher check -1.81%, no regressions.
---
 compiler/rustc_expand/src/mbe/macro_rules.rs  |  32 +-
 compiler/rustc_expand/src/mbe/metavar_expr.rs |   4 +-
 compiler/rustc_expand/src/mbe/transcribe.rs   | 468 ++++++++++++------
 3 files changed, 327 insertions(+), 177 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index e0d7c780c14b6..ef0404d0a8fbe 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -42,7 +42,7 @@ use crate::expand::{AstFragment, AstFragmentKind, ensure_complete_parse, parse_a
 use crate::mbe::macro_check::check_meta_variables;
 use crate::mbe::macro_parser::{Error, ErrorReported, Failure, MatcherLoc, Success, TtParser};
 use crate::mbe::quoted::{RulePart, parse_one_tt};
-use crate::mbe::transcribe::transcribe;
+use crate::mbe::transcribe::{MacroRhs, transcribe};
 use crate::mbe::{self, KleeneOp};
 
 pub(crate) struct ParserAnyMacro<'a, 'b> {
@@ -148,7 +148,7 @@ impl<'a, 'b> ParserAnyMacro<'a, 'b> {
 
 pub(crate) enum MacroRule {
     /// A function-style rule, for use with `m!()`
-    Func { lhs: Vec<MatcherLoc>, lhs_span: Span, rhs: mbe::TokenTree },
+    Func { lhs: Vec<MatcherLoc>, lhs_span: Span, rhs: MacroRhs },
     /// An attr rule, for use with `#[m]`
     Attr {
         unsafe_rule: bool,
@@ -156,10 +156,10 @@ pub(crate) enum MacroRule {
         args_span: Span,
         body: Vec<MatcherLoc>,
         body_span: Span,
-        rhs: mbe::TokenTree,
+        rhs: MacroRhs,
     },
     /// A derive rule, for use with `#[m]`
-    Derive { body: Vec<MatcherLoc>, body_span: Span, rhs: mbe::TokenTree },
+    Derive { body: Vec<MatcherLoc>, body_span: Span, rhs: MacroRhs },
 }
 
 pub struct MacroRulesMacroExpander {
@@ -183,7 +183,7 @@ impl MacroRulesMacroExpander {
             }
             MacroRule::Derive { body_span, ref rhs, .. } => (MultiSpan::from_span(body_span), rhs),
         };
-        if has_compile_error_macro(rhs) { None } else { Some((&self.name, span)) }
+        if has_compile_error_macro(&rhs.tt) { None } else { Some((&self.name, span)) }
     }
 
     pub fn kinds(&self) -> MacroKinds {
@@ -220,12 +220,9 @@ impl MacroRulesMacroExpander {
                 let MacroRule::Derive { rhs, .. } = rule else {
                     panic!("try_match_macro_derive returned non-derive rule");
                 };
-                let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
-                    cx.dcx().span_bug(sp, "malformed macro derive rhs");
-                };
 
                 let id = cx.current_expansion.id;
-                let tts = transcribe(psess, &named_matches, rhs, *rhs_span, self.transparency, id)
+                let tts = transcribe(psess, &named_matches, rhs, self.transparency, id)
                     .map_err(|e| e.emit())?
                     .to_token_stream();
 
@@ -399,14 +396,11 @@ fn expand_macro<'cx, 'a: 'cx>(
             let MacroRule::Func { lhs, rhs, .. } = rule else {
                 panic!("try_match_macro returned non-func rule");
             };
-            let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
-                cx.dcx().span_bug(sp, "malformed macro rhs");
-            };
-            let arm_span = rhs_span.entire();
+            let arm_span = rhs.tt.span();
 
             // rhs has holes ( `$id` and `$(...)` that need filled)
             let id = cx.current_expansion.id;
-            let flat = match transcribe(psess, &named_matches, rhs, *rhs_span, transparency, id) {
+            let flat = match transcribe(psess, &named_matches, rhs, transparency, id) {
                 Ok(flat) => flat,
                 Err(err) => {
                     let guar = err.emit();
@@ -484,9 +478,6 @@ fn expand_macro_attr(
             let MacroRule::Attr { rhs, unsafe_rule, .. } = rule else {
                 panic!("try_macro_match_attr returned non-attr rule");
             };
-            let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
-                cx.dcx().span_bug(sp, "malformed macro rhs");
-            };
 
             match (safety, unsafe_rule) {
                 (Safety::Default, false) | (Safety::Unsafe(_), true) => {}
@@ -502,7 +493,7 @@ fn expand_macro_attr(
             }
 
             let id = cx.current_expansion.id;
-            let tts = transcribe(psess, &named_matches, rhs, *rhs_span, transparency, id)
+            let tts = transcribe(psess, &named_matches, rhs, transparency, id)
                 .map_err(|e| e.emit())?
                 .to_token_stream();
 
@@ -838,11 +829,12 @@ pub fn compile_declarative_macro(
             };
             let args = mbe::macro_parser::compute_locs(&delimited.tts);
             let body_span = lhs_span;
+            let rhs = MacroRhs::new(rhs);
             rules.push(MacroRule::Attr { unsafe_rule, args, args_span, body: lhs, body_span, rhs });
         } else if is_derive {
-            rules.push(MacroRule::Derive { body: lhs, body_span: lhs_span, rhs });
+            rules.push(MacroRule::Derive { body: lhs, body_span: lhs_span, rhs: MacroRhs::new(rhs) });
         } else {
-            rules.push(MacroRule::Func { lhs, lhs_span, rhs });
+            rules.push(MacroRule::Func { lhs, lhs_span, rhs: MacroRhs::new(rhs) });
         }
         if p.token == token::Eof {
             break;
diff --git a/compiler/rustc_expand/src/mbe/metavar_expr.rs b/compiler/rustc_expand/src/mbe/metavar_expr.rs
index a02b84204cb39..3d399ba2fb0b5 100644
--- a/compiler/rustc_expand/src/mbe/metavar_expr.rs
+++ b/compiler/rustc_expand/src/mbe/metavar_expr.rs
@@ -13,7 +13,7 @@ pub(crate) const RAW_IDENT_ERR: &str = "`${concat(..)}` currently does not suppo
 pub(crate) const UNSUPPORTED_CONCAT_ELEM_ERR: &str = "expected identifier or string literal";
 
 /// A meta-variable expression, for expansions based on properties of meta-variables.
-#[derive(Debug, PartialEq, Encodable, Decodable)]
+#[derive(Clone, Debug, PartialEq, Encodable, Decodable)]
 pub(crate) enum MetaVarExpr {
     /// Unification of two or more identifiers.
     Concat(Box<[MetaVarExprConcatElem]>),
@@ -157,7 +157,7 @@ fn iter_span(iter: &TokenStreamIter<'_>) -> Option<Span> {
 
 /// Indicates what is placed in a `concat` parameter. For example, literals
 /// (`${concat("foo", "bar")}`) or adhoc identifiers (`${concat(foo, bar)}`).
-#[derive(Debug, Decodable, Encodable, PartialEq)]
+#[derive(Clone, Debug, Decodable, Encodable, PartialEq)]
 pub(crate) enum MetaVarExprConcatElem {
     /// Identifier WITHOUT a preceding dollar sign, which means that this identifier should be
     /// interpreted as a literal.
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index f7ed65de9a488..a8a49dff88dcb 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -1,9 +1,13 @@
 
+use std::mem;
+use std::sync::OnceLock;
+
 use rustc_ast::token::{
     self, Delimiter, IdentIsRaw, InvisibleOrigin, Lit, LitKind, MetaVarKind, Token, TokenKind,
 };
 use rustc_ast::tokenstream::{
-    DelimSpacing, DelimSpan, FlatSink, FlatTokenCursor, FlatTt, Spacing, TokenStream, TokenTree,
+    DelimSpacing, DelimSpan, FlatEntry, FlatSink, FlatTokenCursor, FlatTt, Spacing, TokenStream,
+    TokenTree,
 };
 use rustc_ast::{ExprKind, StmtKind, TyKind, UnOp};
 use rustc_data_structures::fx::FxHashMap;
@@ -41,10 +45,10 @@ struct TranscrCtx<'psess, 'itp> {
 
     /// 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
-    /// we have yet to expand/are still expanding. We start the stack off with the whole RHS. The
-    /// choice of spacing values doesn't matter.
-    stack: SmallVec<[Frame<'itp>; 1]>,
+    /// We descend into the compiled template of the RHS, expanding things as
+    /// we go. This stack contains the things we have yet to expand/are still
+    /// expanding. We start the stack off with the whole template.
+    stack: SmallVec<[ExecFrame<'itp>; 1]>,
 
     /// A stack of where we are in the repeat expansion.
     ///
@@ -100,44 +104,229 @@ impl Marker {
     }
 }
 
-/// An iterator over the token trees in a delimited token tree (`{ ... }`) or a sequence (`$(...)`).
-struct Frame<'a> {
-    tts: &'a [mbe::TokenTree],
-    idx: usize,
-    kind: FrameKind,
+/// A macro rule RHS: the parsed tree plus its transcription template,
+/// compiled on first expansion so definitions that are never invoked don't
+/// pay for compilation.
+pub(crate) struct MacroRhs {
+    pub(crate) tt: mbe::TokenTree,
+    template: OnceLock<Template>,
+}
+
+impl MacroRhs {
+    pub(crate) fn new(tt: mbe::TokenTree) -> MacroRhs {
+        MacroRhs { tt, template: OnceLock::new() }
+    }
+}
+
+/// A compiled transcription template. The RHS tree is lowered once per rule
+/// into a form transcription can execute directly: runs of literal tokens are
+/// pre-encoded as flat entries ready to be copied into the output buffer, and
+/// metavar occurrences carry their normalization precomputed.
+struct Template {
+    segs: Vec<Seg>,
+}
+
+enum Seg {
+    /// A run of fully literal tokens (including whole literal delimited
+    /// groups), pre-encoded as flat entries with def-site spans and
+    /// run-relative depths and match indices. Spliced by copy; the copied
+    /// spans are then marked in place.
+    Run { entries: Vec<FlatEntry>, matches: Vec<u32> },
+    /// A single literal token whose kind embeds a span needing its own
+    /// marking (`NtIdent`/`NtLifetime`), kept out of runs.
+    Token(Token),
+    /// A delimited group containing non-literal segments.
+    Delimited { span: DelimSpan, spacing: DelimSpacing, delim: Delimiter, inner: Vec<Seg> },
+    /// A metavar occurrence.
+    MetaVar { span: Span, orig: Ident, norm: MacroRulesNormalizedIdent },
+    /// A `$(...)` repetition.
+    Sequence(Box<SeqSeg>),
+    /// A `${...}` metavar expression.
+    MetaVarExpr { dspan: DelimSpan, expr: MetaVarExpr },
+}
+
+struct SeqSeg {
+    inner: Vec<Seg>,
+    sep: Option<Token>,
+    kleene_op: KleeneOp,
+    dspan: DelimSpan,
+    /// The normalized metavar occurrences in the whole subtree, in source
+    /// order, for the lockstep size check.
+    lockstep_vars: Vec<MacroRulesNormalizedIdent>,
+    /// The original metavar idents of the subtree (excluding metavar
+    /// expressions), for the no-repeatable-vars diagnostics.
+    error_meta_vars: Vec<Ident>,
+}
+
+/// A frame of the transcription stack: where we are within one nesting level
+/// of the compiled template.
+enum ExecFrame<'itp> {
+    /// The top-level template; its delimiters are not part of the result.
+    Root { segs: &'itp [Seg], idx: usize },
+    /// Inside a `Seg::Delimited`. The close-delimiter parts are precomputed
+    /// (span already marked) for emission when the frame is popped.
+    Delimited { inner: &'itp [Seg], idx: usize, delim: Delimiter, close_span: Span, close_spacing: Spacing },
+    /// One iteration of a `Seg::Sequence`.
+    Sequence { seq: &'itp SeqSeg, idx: usize },
+}
+
+impl<'itp> ExecFrame<'itp> {
+    fn next_seg(&mut self) -> Option<&'itp Seg> {
+        let (segs, idx) = match self {
+            ExecFrame::Root { segs, idx } => (*segs, idx),
+            ExecFrame::Delimited { inner, idx, .. } => (*inner, idx),
+            ExecFrame::Sequence { seq, idx } => (&seq.inner[..], idx),
+        };
+        let res = segs.get(*idx);
+        *idx += 1;
+        res
+    }
+}
+
+fn compile_template(src: &mbe::Delimited) -> Template {
+    Template { segs: compile_segs(&src.tts) }
+}
+
+fn compile_segs(tts: &[mbe::TokenTree]) -> Vec<Seg> {
+    let mut segs = Vec::new();
+    let mut run = FlatSink::new();
+    for tt in tts {
+        compile_tt(tt, &mut segs, &mut run);
+    }
+    flush_run(&mut segs, &mut run);
+    segs
 }
 
-enum FrameKind {
-    Delimited { delim: Delimiter, span: DelimSpan, spacing: DelimSpacing },
-    Sequence { sep: Option<Token>, kleene_op: KleeneOp },
+fn flush_run(segs: &mut Vec<Seg>, run: &mut FlatSink) {
+    if !run.entries.is_empty() {
+        let entries = mem::take(&mut run.entries);
+        let matches = mem::take(&mut run.matches);
+        segs.push(Seg::Run { entries, matches });
+    }
 }
 
-impl<'a> Frame<'a> {
-    fn new_delimited(src: &'a mbe::Delimited, span: DelimSpan, spacing: DelimSpacing) -> Frame<'a> {
-        Frame {
-            tts: &src.tts,
-            idx: 0,
-            kind: FrameKind::Delimited { delim: src.delim, span, spacing },
+fn compile_tt(tt: &mbe::TokenTree, segs: &mut Vec<Seg>, run: &mut FlatSink) {
+    match tt {
+        mbe::TokenTree::Token(token) => {
+            if matches!(token.kind, token::NtIdent(..) | token::NtLifetime(..)) {
+                flush_run(segs, run);
+                segs.push(Seg::Token(*token));
+            } else {
+                run.push_token(*token, Spacing::Alone);
+            }
+        }
+        mbe::TokenTree::Delimited(span, spacing, delimited) => {
+            if all_literal(&delimited.tts) {
+                emit_literal_delimited(run, *span, *spacing, delimited);
+            } else {
+                flush_run(segs, run);
+                segs.push(Seg::Delimited {
+                    span: *span,
+                    spacing: *spacing,
+                    delim: delimited.delim,
+                    inner: compile_segs(&delimited.tts),
+                });
+            }
+        }
+        &mbe::TokenTree::MetaVar(span, orig) => {
+            flush_run(segs, run);
+            segs.push(Seg::MetaVar { span, orig, norm: MacroRulesNormalizedIdent::new(orig) });
+        }
+        seq_tt @ mbe::TokenTree::Sequence(dspan, seq_rep) => {
+            flush_run(segs, run);
+            let mut lockstep_vars = Vec::new();
+            collect_lockstep_vars(&seq_rep.tts, &mut lockstep_vars);
+            let mut error_meta_vars = Vec::new();
+            seq_tt.meta_vars(&mut error_meta_vars);
+            segs.push(Seg::Sequence(Box::new(SeqSeg {
+                inner: compile_segs(&seq_rep.tts),
+                sep: seq_rep.separator,
+                kleene_op: seq_rep.kleene.op,
+                dspan: *dspan,
+                lockstep_vars,
+                error_meta_vars,
+            })));
+        }
+        mbe::TokenTree::MetaVarExpr(dspan, expr) => {
+            flush_run(segs, run);
+            segs.push(Seg::MetaVarExpr { dspan: *dspan, expr: expr.clone() });
         }
+        // There should be no meta-var declarations in a macro RHS.
+        mbe::TokenTree::MetaVarDecl { .. } => panic!("unexpected `TokenTree::MetaVarDecl`"),
     }
+}
+
+/// Whether every tree is a plain token or a delimited group of plain tokens,
+/// i.e. transcribes to the same entries on every expansion (modulo marking).
+fn all_literal(tts: &[mbe::TokenTree]) -> bool {
+    tts.iter().all(|tt| match tt {
+        mbe::TokenTree::Token(token) => {
+            !matches!(token.kind, token::NtIdent(..) | token::NtLifetime(..))
+        }
+        mbe::TokenTree::Delimited(.., delimited) => all_literal(&delimited.tts),
+        _ => false,
+    })
+}
 
-    fn new_sequence(
-        src: &'a mbe::SequenceRepetition,
-        sep: Option<Token>,
-        kleene_op: KleeneOp,
-    ) -> Frame<'a> {
-        Frame { tts: &src.tts, idx: 0, kind: FrameKind::Sequence { sep, kleene_op } }
+fn emit_literal_delimited(
+    run: &mut FlatSink,
+    span: DelimSpan,
+    spacing: DelimSpacing,
+    delimited: &mbe::Delimited,
+) {
+    run.open_delim(Token::new(delimited.delim.as_open_token_kind(), span.open), spacing.open);
+    for tt in &delimited.tts {
+        match tt {
+            mbe::TokenTree::Token(token) => run.push_token(*token, Spacing::Alone),
+            mbe::TokenTree::Delimited(span, spacing, delimited) => {
+                emit_literal_delimited(run, *span, *spacing, delimited)
+            }
+            _ => unreachable!("non-literal tree in literal delimited group"),
+        }
     }
+    // Hack to force-insert a space after `]` in certain case.
+    // See discussion of the `hex-literal` crate in #114571.
+    let close_spacing =
+        if delimited.delim == Delimiter::Bracket { Spacing::Alone } else { spacing.close };
+    run.close_delim(Token::new(delimited.delim.as_close_token_kind(), span.close), close_spacing);
 }
 
-impl<'a> Iterator for Frame<'a> {
-    type Item = &'a mbe::TokenTree;
+/// Collects the normalized idents of every metavar occurrence in the subtree,
+/// in source order, mirroring the leaves the tree-walking lockstep size check
+/// used to visit.
+fn collect_lockstep_vars(tts: &[mbe::TokenTree], out: &mut Vec<MacroRulesNormalizedIdent>) {
+    for tt in tts {
+        match tt {
+            mbe::TokenTree::Token(_) => {}
+            mbe::TokenTree::MetaVar(_, id) | mbe::TokenTree::MetaVarDecl { name: id, .. } => {
+                out.push(MacroRulesNormalizedIdent::new(*id))
+            }
+            mbe::TokenTree::Delimited(.., d) => collect_lockstep_vars(&d.tts, out),
+            mbe::TokenTree::Sequence(_, s) => collect_lockstep_vars(&s.tts, out),
+            mbe::TokenTree::MetaVarExpr(_, expr) => {
+                expr.for_each_metavar((), |(), ident| {
+                    out.push(MacroRulesNormalizedIdent::new(*ident))
+                });
+            }
+        }
+    }
+}
 
-    fn next(&mut self) -> Option<&'a mbe::TokenTree> {
-        let res = self.tts.get(self.idx);
-        self.idx += 1;
-        res
+/// Appends a pre-encoded literal run to the sink, rebasing the run-relative
+/// depths and match indices, and marks the copied spans in place.
+fn splice_run(sink: &mut FlatSink, entries: &[FlatEntry], matches: &[u32], marker: &mut Marker) {
+    let dst_start = sink.entries.len();
+    let depth = sink.depth();
+    sink.entries.extend(entries.iter().map(|e| FlatEntry {
+        token: e.token,
+        spacing: e.spacing,
+        depth: e.depth + depth,
+    }));
+    for e in &mut sink.entries[dst_start..] {
+        marker.mark_span(&mut e.token.span);
     }
+    let idx_delta = dst_start as u32;
+    sink.matches.extend(matches.iter().map(|&m| if m == 0 { 0 } else { m + idx_delta }));
 }
 
 /// This can do Macro-By-Example transcription.
@@ -163,27 +352,28 @@ impl<'a> Iterator for Frame<'a> {
 pub(super) fn transcribe<'a>(
     psess: &'a ParseSess,
     interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
-    src: &mbe::Delimited,
-    src_span: DelimSpan,
+    rhs: &MacroRhs,
     transparency: Transparency,
     expand_id: LocalExpnId,
 ) -> PResult<'a, FlatTokenCursor> {
+    let mbe::TokenTree::Delimited(_, _, src) = &rhs.tt else {
+        panic!("malformed macro rhs");
+    };
+
     // Nothing for us to transcribe...
     if src.tts.is_empty() {
         return Ok(FlatTokenCursor::from_parts(Vec::new(), Vec::new()));
     }
 
+    let template = rhs.template.get_or_init(|| compile_template(src));
+
     let mut tscx = TranscrCtx {
         psess,
         interp,
         marker: Marker { expand_id, transparency, cache: Default::default() },
         repeats: Vec::new(),
         lookup_cache: SmallVec::new(),
-        stack: smallvec![Frame::new_delimited(
-            src,
-            src_span,
-            DelimSpacing::new(Spacing::Alone, Spacing::Alone)
-        )],
+        stack: smallvec![ExecFrame::Root { segs: &template.segs, idx: 0 }],
         // The output typically contains at least one entry per template
         // token tree, so the template length is a cheap capacity estimate
         // that avoids the initial growth ladder of the result buffer.
@@ -192,19 +382,19 @@ pub(super) fn transcribe<'a>(
 
     loop {
         // Look at the last frame on the stack.
-        // If it still has a TokenTree we have not looked at yet, use that tree.
-        let Some(tree) = tscx.stack.last_mut().unwrap().next() else {
-            // This else-case never produces a value for `tree` (it `continue`s or `return`s).
+        // If it still has a segment we have not looked at yet, use that segment.
+        let Some(seg) = tscx.stack.last_mut().unwrap().next_seg() else {
+            // This else-case never produces a value for `seg` (it `continue`s or `return`s).
 
             // Otherwise, if we have just reached the end of a sequence and we can keep repeating,
             // go back to the beginning of the sequence.
             let frame = tscx.stack.last_mut().unwrap();
-            if let FrameKind::Sequence { sep, .. } = &frame.kind {
+            if let ExecFrame::Sequence { seq, idx } = frame {
                 let (repeat_idx, repeat_len) = tscx.repeats.last_mut().unwrap();
                 *repeat_idx += 1;
                 if repeat_idx < repeat_len {
-                    frame.idx = 0;
-                    if let Some(sep) = sep {
+                    *idx = 0;
+                    if let Some(sep) = &seq.sep {
                         tscx.sink.push_token(*sep, Spacing::Alone);
                     }
                     continue;
@@ -212,82 +402,82 @@ pub(super) fn transcribe<'a>(
             }
 
             // We are done with the top of the stack. Pop it. Depending on what it was, we do
-            // different things. Note that the outermost item must be the delimited, wrapped RHS
-            // that was passed in originally to `transcribe`.
-            match tscx.stack.pop().unwrap().kind {
+            // different things. Note that the outermost item must be the root template.
+            match tscx.stack.pop().unwrap() {
                 // Done with a sequence. Pop from repeats.
-                FrameKind::Sequence { .. } => {
+                ExecFrame::Sequence { .. } => {
                     tscx.repeats.pop();
                     tscx.lookup_cache.clear();
                 }
 
-                // We are done processing a Delimited. If this is the top-level delimited, we are
-                // done (its delimiters are not part of the result). Otherwise, emit the close
-                // delimiter entry.
-                FrameKind::Delimited { delim, span, mut spacing, .. } => {
-                    // Hack to force-insert a space after `]` in certain case.
-                    // See discussion of the `hex-literal` crate in #114571.
-                    if delim == Delimiter::Bracket {
-                        spacing.close = Spacing::Alone;
-                    }
-                    if tscx.stack.is_empty() {
-                        // No results left to compute! We are back at the top-level.
-                        return Ok(tscx.sink.finish());
-                    }
+                // No results left to compute! We are back at the top-level.
+                // (The RHS delimiters are not part of the result.)
+                ExecFrame::Root { .. } => {
+                    return Ok(tscx.sink.finish());
+                }
 
-                    // The delimiter spans were already marked when the frame was entered.
+                // We are done processing a Delimited. Emit the close delimiter
+                // entry; its span was marked when the frame was entered.
+                ExecFrame::Delimited { delim, close_span, close_spacing, .. } => {
                     tscx.sink
-                        .close_delim(Token::new(delim.as_close_token_kind(), span.close), spacing.close);
+                        .close_delim(Token::new(delim.as_close_token_kind(), close_span), close_spacing);
                 }
             }
             continue;
         };
 
-        // At this point, we know we are in the middle of a TokenTree (the last one on `stack`).
-        // `tree` contains the next `TokenTree` to be processed.
-        match tree {
-            // Replace the sequence with its expansion.
-            seq @ mbe::TokenTree::Sequence(_, seq_rep) => {
-                transcribe_sequence(&mut tscx, seq, seq_rep, interp)?;
+        match seg {
+            // Copy a pre-encoded run of literal tokens into the output and
+            // mark the copied spans in place.
+            Seg::Run { entries, matches } => {
+                splice_run(&mut tscx.sink, entries, matches, &mut tscx.marker);
             }
 
-            // Replace the meta-var with the matched token tree from the invocation.
-            &mbe::TokenTree::MetaVar(sp, original_ident) => {
-                transcribe_metavar(&mut tscx, sp, original_ident)?;
+            // A literal token whose kind embeds an extra span to mark.
+            &Seg::Token(mut token) => {
+                tscx.marker.mark_span(&mut token.span);
+                if let token::NtIdent(ident, _) | token::NtLifetime(ident, _) = &mut token.kind {
+                    tscx.marker.mark_span(&mut ident.span);
+                }
+                tscx.sink.push_token(token, Spacing::Alone);
             }
 
-            // Replace meta-variable expressions with the result of their expansion.
-            mbe::TokenTree::MetaVarExpr(dspan, expr) => {
-                transcribe_metavar_expr(&mut tscx, *dspan, expr)?;
+            // If we are entering a new delimiter, emit its open entry and push
+            // its contents to the `stack` to be processed.
+            Seg::Delimited { span, spacing, delim, inner } => {
+                let mut open_span = span.open;
+                let mut close_span = span.close;
+                tscx.marker.mark_span(&mut open_span);
+                tscx.marker.mark_span(&mut close_span);
+                tscx.sink
+                    .open_delim(Token::new(delim.as_open_token_kind(), open_span), spacing.open);
+                // Hack to force-insert a space after `]` in certain case.
+                // See discussion of the `hex-literal` crate in #114571.
+                let close_spacing =
+                    if *delim == Delimiter::Bracket { Spacing::Alone } else { spacing.close };
+                tscx.stack.push(ExecFrame::Delimited {
+                    inner: &inner[..],
+                    idx: 0,
+                    delim: *delim,
+                    close_span,
+                    close_spacing,
+                });
             }
 
-            // If we are entering a new delimiter, we push its contents to the `stack` to be
-            // processed, and we push all of the currently produced results to the `result_stack`.
-            // We will produce all of the results of the inside of the `Delimited` and then we will
-            // jump back out of the Delimited, pop the result_stack and add the new results back to
-            // the previous results (from outside the Delimited).
-            &mbe::TokenTree::Delimited(mut span, ref spacing, ref delimited) => {
-                tscx.marker.mark_span(&mut span.open);
-                tscx.marker.mark_span(&mut span.close);
-                tscx.sink.open_delim(
-                    Token::new(delimited.delim.as_open_token_kind(), span.open),
-                    spacing.open,
-                );
-                tscx.stack.push(Frame::new_delimited(delimited, span, *spacing));
+            // Replace the meta-var with the matched token tree from the invocation.
+            Seg::MetaVar { span, orig, norm } => {
+                transcribe_metavar(&mut tscx, *span, *orig, *norm)?;
             }
 
-            // Nothing much to do here. Just push the token to the result, being careful to
-            // preserve syntax context.
-            &mbe::TokenTree::Token(mut token) => {
-                tscx.marker.mark_span(&mut token.span);
-                if let token::NtIdent(ident, _) | token::NtLifetime(ident, _) = &mut token.kind {
-                    tscx.marker.mark_span(&mut ident.span);
-                }
-                tscx.sink.push_token(token, Spacing::Alone);
+            // Replace the sequence with its expansion.
+            Seg::Sequence(seq) => {
+                transcribe_sequence(&mut tscx, seq)?;
             }
 
-            // There should be no meta-var declarations in the invocation of a macro.
-            mbe::TokenTree::MetaVarDecl { .. } => panic!("unexpected `TokenTree::MetaVarDecl`"),
+            // Replace meta-variable expressions with the result of their expansion.
+            Seg::MetaVarExpr { dspan, expr } => {
+                transcribe_metavar_expr(&mut tscx, *dspan, expr)?;
+            }
         }
     }
 }
@@ -295,10 +485,7 @@ pub(super) fn transcribe<'a>(
 /// Turn `$(...)*` sequences into tokens.
 fn transcribe_sequence<'tx, 'itp>(
     tscx: &mut TranscrCtx<'tx, 'itp>,
-    seq: &mbe::TokenTree,
-    seq_rep: &'itp mbe::SequenceRepetition,
-    // Used only for better diagnostics in the face of typos.
-    interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
+    seq: &'itp SeqSeg,
 ) -> PResult<'tx, ()> {
     let dcx = tscx.psess.dcx();
 
@@ -311,7 +498,7 @@ fn transcribe_sequence<'tx, 'itp>(
             let mut non_repeatables = Vec::new();
 
             #[allow(rustc::potential_query_instability)]
-            for (name, matcher) in interp.iter() {
+            for (name, matcher) in tscx.interp.iter() {
                 if matcher.is_repeatable() {
                     repeatables.push(name);
                 } else {
@@ -323,15 +510,14 @@ fn transcribe_sequence<'tx, 'itp>(
                 repeatables.iter().map(|&name| name.symbol()).collect();
             let non_repeatable_names: Vec<Symbol> =
                 non_repeatables.iter().map(|&name| name.symbol()).collect();
-            let mut meta_vars = vec![];
-            seq.meta_vars(&mut meta_vars);
+            let meta_vars = &seq.error_meta_vars;
             let mut typo_repeatable = None;
             let mut typo_unrepeatable = None;
             let mut typo_unrepeatable_label = None;
             let mut var_no_typo = None;
             let mut no_repeatable_var = None;
 
-            for ident in meta_vars {
+            for &ident in meta_vars {
                 if let Some(name) = rustc_span::edit_distance::find_best_match_for_name(
                     &repeatable_names[..],
                     ident.name,
@@ -360,7 +546,7 @@ fn transcribe_sequence<'tx, 'itp>(
                 }
             }
             return Err(dcx.create_err(NoSyntaxVarsExprRepeat {
-                span: seq.span(),
+                span: seq.dspan.entire(),
                 typo_unrepeatable,
                 typo_repeatable,
                 typo_unrepeatable_label,
@@ -374,21 +560,17 @@ fn transcribe_sequence<'tx, 'itp>(
             // happens when two meta-variables are used in the same repetition in a
             // sequence, but they come from different sequence matchers and repeat
             // different amounts.
-            return Err(dcx.create_err(MetaVarsDifSeqMatchers { span: seq.span(), msg }));
+            return Err(dcx.create_err(MetaVarsDifSeqMatchers { span: seq.dspan.entire(), msg }));
         }
 
         LockstepIterSize::Constraint(len, _) => {
-            // We do this to avoid an extra clone above. We know that this is a
-            // sequence already.
-            let mbe::TokenTree::Sequence(sp, seq) = seq else { unreachable!() };
-
             // Is the repetition empty?
             if len == 0 {
-                if seq.kleene.op == KleeneOp::OneOrMore {
+                if seq.kleene_op == KleeneOp::OneOrMore {
                     // FIXME: this really ought to be caught at macro definition
                     // time... It happens when the Kleene operator in the matcher and
                     // the body for the same meta-variable do not match.
-                    return Err(dcx.create_err(MustRepeatOnce { span: sp.entire() }));
+                    return Err(dcx.create_err(MustRepeatOnce { span: seq.dspan.entire() }));
                 }
             } else {
                 // 0 is the initial counter (we have done 0 repetitions so far). `len`
@@ -399,7 +581,7 @@ fn transcribe_sequence<'tx, 'itp>(
                 // The first time we encounter the sequence we push it to the stack. It
                 // then gets reused (see the beginning of the loop) until we are done
                 // repeating.
-                tscx.stack.push(Frame::new_sequence(seq_rep, seq.separator, seq.kleene.op));
+                tscx.stack.push(ExecFrame::Sequence { seq, idx: 0 });
             }
         }
     }
@@ -427,10 +609,10 @@ fn transcribe_metavar<'tx>(
     tscx: &mut TranscrCtx<'tx, '_>,
     mut sp: Span,
     mut original_ident: Ident,
+    ident: MacroRulesNormalizedIdent,
 ) -> PResult<'tx, ()> {
     let dcx = tscx.psess.dcx();
 
-    let ident = MacroRulesNormalizedIdent::new(original_ident);
     let Some(cur_matched) = lookup_cur_matched_cached(tscx, ident) else {
         // If we aren't able to match the meta-var, we push it back into the result but
         // with modified syntax context. (I believe this supports nested macros).
@@ -686,15 +868,15 @@ fn transcribe_flat_tt(tscx: &mut TranscrCtx<'_, '_>, metavar_span: Span, ftt: &F
     let mut metavar_span = metavar_span;
     let undelimited_seq = matches!(
         tscx.stack.last(),
-        Some(Frame {
-            tts: [_],
-            kind: FrameKind::Sequence {
+        Some(ExecFrame::Sequence {
+            seq: SeqSeg {
+                inner,
                 sep: None,
                 kleene_op: KleeneOp::ZeroOrMore | KleeneOp::OneOrMore,
                 ..
             },
             ..
-        })
+        }) if inner.len() == 1
     );
     if undelimited_seq {
         // Do not record metavar spans for tokens from undelimited sequences, for perf reasons.
@@ -898,8 +1080,8 @@ impl LockstepIterSize {
     }
 }
 
-/// Given a `tree`, make sure that all sequences have the same length as the matches for the
-/// appropriate meta-vars in `interpolations`.
+/// Given a sequence, make sure that all of its metavar occurrences have the same length as the
+/// matches for the appropriate meta-vars in `interpolations`.
 ///
 /// Note that if `repeats` does not match the exact correct depth of a meta-var,
 /// `lookup_cur_matched` will return `None`, which is why this still works even in the presence of
@@ -911,43 +1093,19 @@ impl LockstepIterSize {
 /// 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.
 fn lockstep_iter_size(
-    tree: &mbe::TokenTree,
+    seq: &SeqSeg,
     interpolations: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
     repeats: &[(usize, usize)],
 ) -> LockstepIterSize {
-    use mbe::TokenTree;
-    match tree {
-        TokenTree::Delimited(.., delimited) => {
-            delimited.tts.iter().fold(LockstepIterSize::Unconstrained, |size, tt| {
-                size.with(lockstep_iter_size(tt, interpolations, repeats))
-            })
-        }
-        TokenTree::Sequence(_, seq) => {
-            seq.tts.iter().fold(LockstepIterSize::Unconstrained, |size, tt| {
-                size.with(lockstep_iter_size(tt, interpolations, repeats))
-            })
-        }
-        TokenTree::MetaVar(_, name) | TokenTree::MetaVarDecl { name, .. } => {
-            let name = MacroRulesNormalizedIdent::new(*name);
-            match lookup_cur_matched(name, interpolations, repeats) {
-                Some(matched) => match matched {
-                    MatchedSingle(_) => LockstepIterSize::Unconstrained,
-                    MatchedSeq(ads) => LockstepIterSize::Constraint(ads.len(), name),
-                },
-                _ => LockstepIterSize::Unconstrained,
-            }
-        }
-        TokenTree::MetaVarExpr(_, expr) => {
-            expr.for_each_metavar(LockstepIterSize::Unconstrained, |lis, ident| {
-                lis.with(lockstep_iter_size(
-                    &TokenTree::MetaVar(ident.span, *ident),
-                    interpolations,
-                    repeats,
-                ))
-            })
-        }
-        TokenTree::Token(..) => LockstepIterSize::Unconstrained,
+    let mut size = LockstepIterSize::Unconstrained;
+    for &name in &seq.lockstep_vars {
+        let var_size = match lookup_cur_matched(name, interpolations, repeats) {
+            Some(MatchedSeq(ads)) => LockstepIterSize::Constraint(ads.len(), name),
+            _ => LockstepIterSize::Unconstrained,
+        };
+        size = size.with(var_size);
     }
+    size
 }
 
 /// Used solely by the `count` meta-variable expression, counts the outermost repetitions at a