Syntax backtraces don't work for the new macro system

[paulstansifer]

log_syntax! should emit, in this case, information about the invocation of my_complex_macro(), but doesn't. I believe that this can be fixed by having transcribe.rs set up expn_info the way that simplext.rs does.

macro_rules! my_complex_macro {
    { } => { log_syntax!("asdf"); }
}

fn main() {
    io::println(my_complex_macro!());
}

[catamorphism]

Not critical for 0.6, de-milestoning

[bstrie]

What's the expected output here? Running the example gives:

⌁ rustc 3065.rs
"asdf"
3065.rs:6:16: 6:36 error: mismatched types: expected `&str` but found `()` (expected &str but found ())
3065.rs:6     io::println(my_complex_macro!());
                          ^~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error

[paulstansifer]

It should give a "backtrace" of errors, indicating both of the invocations that led to the error.

[catamorphism]

Nominating for milestone 3, feature-complete

[graydon]

accepted for production-ready milestone

[catamorphism]

(bug triage) Milestone still looks right; carry on.

[pnkfelix]

we should feature-guard whatever this log-syntax thing is.

[pnkfelix]

under assumption log_syntax gets feature guarded, this is accepted for P-low

[steveklabnik]

log_syntax is now Active, but this is still a bug.

[carols10cents]

(Hi, I'm trying to help make E-easy issues more accessible to newcomers 😸)

I tried reproducing this and it compiles and prints "asdf". From the book chapter on macros:

log_syntax!(...) will print its arguments to standard output, at compile time, and "expand" to nothing.

This sounds like log_syntax! is behaving as expected? Unless "its arguments" is referring to the macro's arguments as opposed to log_syntax!'s arguments...?

I'm also not sure how to interpret paulstansifer's comment:

It should give a "backtrace" of errors, indicating both of the invocations that led to the error.

What error is this referring to? Which two invocations is this referring to?

Basically... is this still an issue? If so, it's sounding more like an additional feature to log_syntax!, not a bug...?

[paulstansifer]

@carols10cents That's a great idea. I'm not 100% sure that this is E-Easy, as it requires some knowledge of the internals of macro expansion.

The "syntactic backtrace" is analogous to, but totally distinct from, the standard idea of a backtrace. In the following example (my original example is not great):

#![feature(log_syntax)]

macro_rules! macro_2 {
    { } => { log_syntax!("asdf"); }
}

macro_rules! macro_1 {
    { } => { macro_2!() }
}

fn main() {
    macro_1!();
}

...Rust should print out the sequence of macro invocations that led to log_syntax!() being invoked:

test.rs:4:10 asdf
...while expanding:
test.rs:8:10 macro_2!()
...while expanding:
test.rs:12:1 macro_1!()

I think that the facility for printing syntactic backtraces exists, but it's not getting the right information.

[brson]

Not easy!