Consider propagating rustc's compile_error representation as a token

[dtolnay]

$ rustc -Zunpretty=expanded <(echo 'fn main() { let _ = compile_error!("..."); }')

Stderr:

error: ...
 --> /dev/fd/63:1:21
  |
1 | fn main() { let _ = compile_error!("..."); }
  |                     ^^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error

Stdout:

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::rust_2015::*;
#[macro_use]
extern crate std;
fn main() { let _ = (/*ERROR*/); }

Notice that an error during macro expansion materializes in the expanded code in the form (/*ERROR*/).

This corresponds to rustc_ast's ExprKind::Err. https://github.com/rust-lang/rust/blob/1.72.0/compiler/rustc_ast/src/ast.rs#L1533-L1534

All expansion errors in expression position and type position are treated this way, such as a failure to match rule during macro_rules expansion, a procedural macro panic, or invalid token stream produced by a macro. (Macro failure in pattern position instead appears as _, and in item position the whole item is omitted.)

We should consider whether it would be appropriate for proc-macro2 to capture /*ERROR*/, or (/*ERROR*/), when parsed by our fallback parser. Most likely this would take the form of parsing it into TokenTree::Literal. For the above code snippet, syn would get a syntax tree resembling:

Stmt::Local {
    attrs: [],
    let_token: Token![let],
    pat: Pat::Wild {
        attrs: [],
        underscore_token: Token![_],
    },
    init: Some(LocalInit {
        eq_token: Token![=],
        expr: Expr::Lit {
            attrs: [],
            lit: Lit::Verbatim(
                Literal {
                    kind: Err,
                    symbol: "(/*ERROR*/)",
                },
            ),
        },
    }),
    semi_token: Token![;],
}