Can macros match against constant arguments instead of literals?

Question

Given the macro matching example, this shows how macros can match an argument.

I've made very minor changes here to use numbers:

macro_rules! foo {
    (0 => $e:expr) => (println!("mode X: {}", $e));
    (1 => $e:expr) => (println!("mode Y: {}", $e));
}

fn main() {
    foo!(1 => 3);
}

Works, printing: mode Y: 3

However I would like to use a constant as an argument, can this be made to work:

const CONST: usize = 1;

macro_rules! foo {
    (0 => $e:expr) => (println!("mode X: {}", $e));
    (1 => $e:expr) => (println!("mode Y: {}", $e));
}

fn main() {
    foo!(CONST => 3);
}

Is this possible in Rust?

---

Note, using a regular match statement isn't usable for me, since in my code each branch resolves to different types, giving an error. So I'm specifically interested to know if a constant can be passed to a macro.

Answer 1

No.

Macros operate on the Abstract Syntax Tree, so they reason at the syntactic level: they reason about tokens and their spelling.

For example:

fn main() {
    let v = 3;
}

In this case, the AST will look something like:

fn main
    \_ let-binding v
        \_ literal 3

If you ask a macro whether v is 3, it will look at you funny, and wonder why you would try comparing a variable name and a literal.

Answer 2

I'm fairly sure the answer is "no"; at macro expansion time all you have are token trees - expansion happens before evaluation, or even type inference/checking.

Answer 3

const CONST: usize = 0;

macro_rules! foo {
    ($i:ident => $e:expr) => {
        if $i == 0 {
            println!("mode X: {}", $e);
        } else if $i == 1 {
            println!("mode Y: {}", $e);
        }
    };
}

fn main() {
    foo!(CONST => 3);
}

If you want use identifier in macro it needs to be ident tag and you can use if, else if blocks instead of match.