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!

[brson]

The backtrace behavior described in the op may actually be referring to trace_macros!. It seems like log_syntax purposely just stringifies ASTs and dumps them.

[steveklabnik]

Triage: this issue is so old that "new macro system" refers to the macro system that we're about to soft deprecate 😆 🤣

I'm not sure if this is something that is still relevant or will be addressed. The whole feature is describe as a "hack that is likely to be removed."

As such, I'm going to close this. RIP a four-digit issue.