1 use crate::base::{self, *};
2 use crate::proc_macro_server;
7 use rustc_ast::tokenstream::TokenStream;
8 use rustc_data_structures::sync::Lrc;
9 use rustc_errors::ErrorGuaranteed;
10 use rustc_parse::parser::ForceCollect;
11 use rustc_session::config::ProcMacroExecutionStrategy;
12 use rustc_span::profiling::SpannedEventArgRecorder;
13 use rustc_span::{Span, DUMMY_SP};
15 struct CrossbeamMessagePipe<T> {
16 tx: crossbeam_channel::Sender<T>,
17 rx: crossbeam_channel::Receiver<T>,
20 impl<T> pm::bridge::server::MessagePipe<T> for CrossbeamMessagePipe<T> {
21 fn new() -> (Self, Self) {
22 let (tx1, rx1) = crossbeam_channel::bounded(1);
23 let (tx2, rx2) = crossbeam_channel::bounded(1);
24 (CrossbeamMessagePipe { tx: tx1, rx: rx2 }, CrossbeamMessagePipe { tx: tx2, rx: rx1 })
27 fn send(&mut self, value: T) {
28 self.tx.send(value).unwrap();
31 fn recv(&mut self) -> Option<T> {
36 fn exec_strategy(ecx: &ExtCtxt<'_>) -> impl pm::bridge::server::ExecutionStrategy {
37 pm::bridge::server::MaybeCrossThread::<CrossbeamMessagePipe<_>>::new(
38 ecx.sess.opts.unstable_opts.proc_macro_execution_strategy
39 == ProcMacroExecutionStrategy::CrossThread,
43 pub struct BangProcMacro {
44 pub client: pm::bridge::client::Client<pm::TokenStream, pm::TokenStream>,
47 impl base::BangProcMacro for BangProcMacro {
50 ecx: &'cx mut ExtCtxt<'_>,
53 ) -> Result<TokenStream, ErrorGuaranteed> {
55 ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
56 recorder.record_arg_with_span(ecx.expansion_descr(), span);
59 let proc_macro_backtrace = ecx.ecfg.proc_macro_backtrace;
60 let strategy = exec_strategy(ecx);
61 let server = proc_macro_server::Rustc::new(ecx);
62 self.client.run(&strategy, server, input, proc_macro_backtrace).map_err(|e| {
63 let mut err = ecx.struct_span_err(span, "proc macro panicked");
64 if let Some(s) = e.as_str() {
65 err.help(&format!("message: {}", s));
72 pub struct AttrProcMacro {
73 pub client: pm::bridge::client::Client<(pm::TokenStream, pm::TokenStream), pm::TokenStream>,
76 impl base::AttrProcMacro for AttrProcMacro {
79 ecx: &'cx mut ExtCtxt<'_>,
81 annotation: TokenStream,
82 annotated: TokenStream,
83 ) -> Result<TokenStream, ErrorGuaranteed> {
85 ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
86 recorder.record_arg_with_span(ecx.expansion_descr(), span);
89 let proc_macro_backtrace = ecx.ecfg.proc_macro_backtrace;
90 let strategy = exec_strategy(ecx);
91 let server = proc_macro_server::Rustc::new(ecx);
92 self.client.run(&strategy, server, annotation, annotated, proc_macro_backtrace).map_err(
94 let mut err = ecx.struct_span_err(span, "custom attribute panicked");
95 if let Some(s) = e.as_str() {
96 err.help(&format!("message: {}", s));
104 pub struct DeriveProcMacro {
105 pub client: pm::bridge::client::Client<pm::TokenStream, pm::TokenStream>,
108 impl MultiItemModifier for DeriveProcMacro {
111 ecx: &mut ExtCtxt<'_>,
113 _meta_item: &ast::MetaItem,
115 _is_derive_const: bool,
116 ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
117 // We need special handling for statement items
118 // (e.g. `fn foo() { #[derive(Debug)] struct Bar; }`)
119 let is_stmt = matches!(item, Annotatable::Stmt(..));
120 let hack = crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess.parse_sess);
121 let input = if hack {
122 let nt = match item {
123 Annotatable::Item(item) => token::NtItem(item),
124 Annotatable::Stmt(stmt) => token::NtStmt(stmt),
127 TokenStream::token_alone(token::Interpolated(Lrc::new(nt)), DUMMY_SP)
134 ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
135 recorder.record_arg_with_span(ecx.expansion_descr(), span);
137 let proc_macro_backtrace = ecx.ecfg.proc_macro_backtrace;
138 let strategy = exec_strategy(ecx);
139 let server = proc_macro_server::Rustc::new(ecx);
140 match self.client.run(&strategy, server, input, proc_macro_backtrace) {
141 Ok(stream) => stream,
143 let mut err = ecx.struct_span_err(span, "proc-macro derive panicked");
144 if let Some(s) = e.as_str() {
145 err.help(&format!("message: {}", s));
148 return ExpandResult::Ready(vec![]);
153 let error_count_before = ecx.sess.parse_sess.span_diagnostic.err_count();
155 rustc_parse::stream_to_parser(&ecx.sess.parse_sess, stream, Some("proc-macro derive"));
156 let mut items = vec![];
159 match parser.parse_item(ForceCollect::No) {
163 items.push(Annotatable::Stmt(P(ecx.stmt_item(span, item))));
165 items.push(Annotatable::Item(item));
175 // fail if there have been errors emitted
176 if ecx.sess.parse_sess.span_diagnostic.err_count() > error_count_before {
177 ecx.struct_span_err(span, "proc-macro derive produced unparseable tokens").emit();
180 ExpandResult::Ready(items)