Weird error spans when using metavariable twice

[madsmtm]

Code

macro_rules! consume {
    ($($t:tt)*) => {};
}

macro_rules! use_first_tt {
    ($first:tt $($rest:tt)*) => {
        consume!($first); // Added
        $first $($rest)*
        // This part is included in the span as well
    };
}

use_first_tt! {
    compile_error!("foo");
}

Current output

error: foo
  --> src/lib.rs:8:9
   |
8  | /         $first $($rest)*
9  | |         // This part is included in the span as well
10 | |     };
...  |
13 | | use_first_tt! {
14 | |     compile_error!("foo");
   | |_________________________^

Desired output

error: foo
  --> src/lib.rs:14:5
   |
14 |     compile_error!("foo");
   |     ^^^^^^^^^^^^^^^^^^^^^

Rationale and extra context

It seems that the ctxt of $first is parsed wrongly, which causes the span merging (Span::to) to think that $first and the arguments ("foo") are in the same context, and can be merged directly.

This seems to only happen when using the $ident metavariable twice; if I remove the first use as follows, the output is as expected:

macro_rules! do_not_use_first_tt {
    ($ident:tt $($rest:tt)*) => {
        $ident $($rest)*
    };
}

do_not_use_first_tt! {
    compile_error!("foo");
}

Rust Version

$ rustc +nightly --version --verbose
rustc 1.91.0-nightly (160e7623e 2025-08-26)
binary: rustc
commit-hash: 160e7623e8cbbf1feab2b6e2a24733a98c7bde9c
commit-date: 2025-08-26
host: aarch64-apple-darwin
release: 1.91.0-nightly
LLVM version: 21.1.0

[konnorandrews]

I encountered this bug when I was messing around with span manipulation. Here is some extra info about the behavior.

In a proc macro crate:

use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, TokenStream, TokenTree};

#[proc_macro]
pub fn record(item: TokenStream) -> TokenStream {
    let mut i = dbg!(item).into_iter();
    let start = i.next().unwrap().span();
    let end = i.next().unwrap().span();

    [
        TokenTree::Ident(Ident::new("compile_error", start)),
        TokenTree::Punct(Punct::new('!', Spacing::Alone)),
        TokenTree::Group({
            let mut g = Group::new(
                Delimiter::Brace,
                [TokenTree::Literal(Literal::string("badness 9000"))]
                    .into_iter()
                    .collect(),
            );
            g.set_span(end);
            g
        }),
    ]
    .into_iter()
    .collect()
}

In an integration test or another crate:

macro_rules! repeat {
    ($x:tt) => {
        my_proc_macro::record!($x $x);
    };
}

repeat!(a);

We get the diagnostic spanning across the macro body and invocation.

error: badness 9000
 --> tests/demo.rs:5:20
  |
5 |           record!($x $x);
  |  ____________________^
6 | |     };
... |
9 | | repeat!(a);
  | |_________^

If we inspect the input tokens they are:

[src/lib.rs:5:17] item = TokenStream [
    Ident {
        ident: "a",
        span: #0 bytes(114..115),
    },
    Ident {
        ident: "a",
        span: #0 bytes(91..93),
    },
]

The second a is getting the byte range from the macro body, but the context of the calling context. This lets them merge in the diagnostic.