`$crate` is treated as a normal identifier in a `macro_rules` matcher

[theemathas]

I've found that, in some cases, inside a macro_rules matcher (the thing on the left of the =>), $crate is treated as if it's a normal identifier, which seems very weird. I'm not sure if this is intended or a bug.

This weirdness manifests in two different ways:

1. A $crate on its own in the matcher is treated as literally matching $crate, as opposed to being a metavariable or erroring:

macro_rules! foo {
    ($crate and $crate:tt) => {
        "wtf"
    }
}

macro_rules! bar {
    () => {
        foo!($crate and $crate:tt)
    }
}

fn main() {
    println!("{}", bar!());  // prints "wtf"
}

2. I can create a metavariable (e.g., the metavariable $x:tt has the name x) such that the metavariable's name is $crate:

macro_rules! bar {
    ($dol:tt) => {
        macro_rules! foo {
            ($dol $crate : expr) => { $dol $crate }
        }
    }
}

bar!($);

fn main() {
    println!("{}", foo!(1 + 2));  // prints 3
}

See also #146967 and #146968 and #146114 for weirdness with $crate.

Meta

Reproducible on the playground with version 1.92.0-nightly (2025-09-24 caccb4d0368bd918ef66)

[ehuss]

For the first one, I would say that $crate isn't an identifier. It is the $ token followed by the identifier crate.

We do document that for the purpose of being a fragment specifier, the identifier cannot be crate: https://doc.rust-lang.org/nightly/reference/macros-by-example.html#grammar-MacroMatch. Thus $crate:tt is just 4 tokens in a row, not a fragment specifier.

The second one does seem a little weird to me, though if I do some mental gymnastics of thinking $crate is a pseudo identifier in that situation, it kinda makes sense.

[theemathas]

@ehuss The first case is treating $crate as a single identifier. See the following:

macro_rules! foo {
    ($crate) => {}
}

macro_rules! bar {
    ($dollar:tt) => {
        foo!($dollar crate)
    }
}

fn main() {
    bar!($);
}

error: no rules expected `$`
  --> src/main.rs:12:10
   |
 1 | macro_rules! foo {
   | ---------------- when calling this macro
...
12 |     bar!($);
   |          ^ no rules expected this token in macro call
   |
note: while trying to match reserved identifier `$crate`
  --> src/main.rs:2:6
   |
 2 |     ($crate) => {}
   |      ^^^^^^

[petrochenkov]

IIRC we discussed this before in some previous issue.
On RHS treating expanded $crate as an identifier makes sense, there's no better option.
On LHS it doesn't make much sense, but it is not too important to change (with potential breakage).