1 use crate::base::{self, *};
2 use crate::proc_macro_server;
7 use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, TokenStream, TokenTree};
8 use rustc_data_structures::sync::Lrc;
9 use rustc_errors::ErrorReported;
10 use rustc_parse::nt_to_tokenstream;
11 use rustc_parse::parser::ForceCollect;
12 use rustc_span::def_id::CrateNum;
13 use rustc_span::{Span, DUMMY_SP};
15 const EXEC_STRATEGY: pm::bridge::server::SameThread = pm::bridge::server::SameThread;
17 pub struct BangProcMacro {
18 pub client: pm::bridge::client::Client<fn(pm::TokenStream) -> pm::TokenStream>,
22 impl base::ProcMacro for BangProcMacro {
25 ecx: &'cx mut ExtCtxt<'_>,
28 ) -> Result<TokenStream, ErrorReported> {
29 let server = proc_macro_server::Rustc::new(ecx, self.krate);
30 self.client.run(&EXEC_STRATEGY, server, input, ecx.ecfg.proc_macro_backtrace).map_err(|e| {
31 let mut err = ecx.struct_span_err(span, "proc macro panicked");
32 if let Some(s) = e.as_str() {
33 err.help(&format!("message: {}", s));
41 pub struct AttrProcMacro {
42 pub client: pm::bridge::client::Client<fn(pm::TokenStream, pm::TokenStream) -> pm::TokenStream>,
46 impl base::AttrProcMacro for AttrProcMacro {
49 ecx: &'cx mut ExtCtxt<'_>,
51 annotation: TokenStream,
52 annotated: TokenStream,
53 ) -> Result<TokenStream, ErrorReported> {
54 let server = proc_macro_server::Rustc::new(ecx, self.krate);
56 .run(&EXEC_STRATEGY, server, annotation, annotated, ecx.ecfg.proc_macro_backtrace)
58 let mut err = ecx.struct_span_err(span, "custom attribute panicked");
59 if let Some(s) = e.as_str() {
60 err.help(&format!("message: {}", s));
68 pub struct ProcMacroDerive {
69 pub client: pm::bridge::client::Client<fn(pm::TokenStream) -> pm::TokenStream>,
73 impl MultiItemModifier for ProcMacroDerive {
76 ecx: &mut ExtCtxt<'_>,
78 _meta_item: &ast::MetaItem,
80 ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
81 // We need special handling for statement items
82 // (e.g. `fn foo() { #[derive(Debug)] struct Bar; }`)
83 let mut is_stmt = false;
84 let item = match item {
85 Annotatable::Item(item) => token::NtItem(item),
86 Annotatable::Stmt(stmt) => {
88 assert!(stmt.is_item());
90 // A proc macro can't observe the fact that we're passing
91 // them an `NtStmt` - it can only see the underlying tokens
92 // of the wrapped item
93 token::NtStmt(stmt.into_inner())
97 let input = if crate::base::pretty_printing_compatibility_hack(&item, &ecx.sess.parse_sess)
99 TokenTree::token(token::Interpolated(Lrc::new(item)), DUMMY_SP).into()
101 nt_to_tokenstream(&item, &ecx.sess.parse_sess, CanSynthesizeMissingTokens::No)
104 let server = proc_macro_server::Rustc::new(ecx, self.krate);
106 match self.client.run(&EXEC_STRATEGY, server, input, ecx.ecfg.proc_macro_backtrace) {
107 Ok(stream) => stream,
109 let mut err = ecx.struct_span_err(span, "proc-macro derive panicked");
110 if let Some(s) = e.as_str() {
111 err.help(&format!("message: {}", s));
114 return ExpandResult::Ready(vec![]);
118 let error_count_before = ecx.sess.parse_sess.span_diagnostic.err_count();
120 rustc_parse::stream_to_parser(&ecx.sess.parse_sess, stream, Some("proc-macro derive"));
121 let mut items = vec![];
124 match parser.parse_item(ForceCollect::No) {
128 items.push(Annotatable::Stmt(P(ecx.stmt_item(span, item))));
130 items.push(Annotatable::Item(item));
140 // fail if there have been errors emitted
141 if ecx.sess.parse_sess.span_diagnostic.err_count() > error_count_before {
142 ecx.struct_span_err(span, "proc-macro derive produced unparseable tokens").emit();
145 ExpandResult::Ready(items)