compiler/rustc_expand/src/proc_macro.rs

   1 use crate::base::{self, *};
   2 use crate::proc_macro_server;
   3
   4 use rustc_ast as ast;
   5 use rustc_ast::ptr::P;
   6 use rustc_ast::token;
   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};
  14
  15 struct CrossbeamMessagePipe<T> {
  16     tx: crossbeam_channel::Sender<T>,
  17     rx: crossbeam_channel::Receiver<T>,
  18 }
  19
  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 })
  25     }
  26
  27     fn send(&mut self, value: T) {
  28         self.tx.send(value).unwrap();
  29     }
  30
  31     fn recv(&mut self) -> Option<T> {
  32         self.rx.recv().ok()
  33     }
  34 }
  35
  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,
  40     )
  41 }
  42
  43 pub struct BangProcMacro {
  44     pub client: pm::bridge::client::Client<pm::TokenStream, pm::TokenStream>,
  45 }
  46
  47 impl base::BangProcMacro for BangProcMacro {
  48     fn expand<'cx>(
  49         &self,
  50         ecx: &'cx mut ExtCtxt<'_>,
  51         span: Span,
  52         input: TokenStream,
  53     ) -> Result<TokenStream, ErrorGuaranteed> {
  54         let _timer =
  55             ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
  56                 recorder.record_arg_with_span(ecx.expansion_descr(), span);
  57             });
  58
  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));
  66             }
  67             err.emit()
  68         })
  69     }
  70 }
  71
  72 pub struct AttrProcMacro {
  73     pub client: pm::bridge::client::Client<(pm::TokenStream, pm::TokenStream), pm::TokenStream>,
  74 }
  75
  76 impl base::AttrProcMacro for AttrProcMacro {
  77     fn expand<'cx>(
  78         &self,
  79         ecx: &'cx mut ExtCtxt<'_>,
  80         span: Span,
  81         annotation: TokenStream,
  82         annotated: TokenStream,
  83     ) -> Result<TokenStream, ErrorGuaranteed> {
  84         let _timer =
  85             ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
  86                 recorder.record_arg_with_span(ecx.expansion_descr(), span);
  87             });
  88
  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(
  93             |e| {
  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));
  97                 }
  98                 err.emit()
  99             },
 100         )
 101     }
 102 }
 103
 104 pub struct DeriveProcMacro {
 105     pub client: pm::bridge::client::Client<pm::TokenStream, pm::TokenStream>,
 106 }
 107
 108 impl MultiItemModifier for DeriveProcMacro {
 109     fn expand(
 110         &self,
 111         ecx: &mut ExtCtxt<'_>,
 112         span: Span,
 113         _meta_item: &ast::MetaItem,
 114         item: Annotatable,
 115     ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
 116         // We need special handling for statement items
 117         // (e.g. `fn foo() { #[derive(Debug)] struct Bar; }`)
 118         let is_stmt = matches!(item, Annotatable::Stmt(..));
 119         let hack = crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess.parse_sess);
 120         let input = if hack {
 121             let nt = match item {
 122                 Annotatable::Item(item) => token::NtItem(item),
 123                 Annotatable::Stmt(stmt) => token::NtStmt(stmt),
 124                 _ => unreachable!(),
 125             };
 126             TokenStream::token_alone(token::Interpolated(Lrc::new(nt)), DUMMY_SP)
 127         } else {
 128             item.to_tokens()
 129         };
 130
 131         let stream = {
 132             let _timer =
 133                 ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
 134                     recorder.record_arg_with_span(ecx.expansion_descr(), span);
 135                 });
 136             let proc_macro_backtrace = ecx.ecfg.proc_macro_backtrace;
 137             let strategy = exec_strategy(ecx);
 138             let server = proc_macro_server::Rustc::new(ecx);
 139             match self.client.run(&strategy, server, input, proc_macro_backtrace) {
 140                 Ok(stream) => stream,
 141                 Err(e) => {
 142                     let mut err = ecx.struct_span_err(span, "proc-macro derive panicked");
 143                     if let Some(s) = e.as_str() {
 144                         err.help(&format!("message: {}", s));
 145                     }
 146                     err.emit();
 147                     return ExpandResult::Ready(vec![]);
 148                 }
 149             }
 150         };
 151
 152         let error_count_before = ecx.sess.parse_sess.span_diagnostic.err_count();
 153         let mut parser =
 154             rustc_parse::stream_to_parser(&ecx.sess.parse_sess, stream, Some("proc-macro derive"));
 155         let mut items = vec![];
 156
 157         loop {
 158             match parser.parse_item(ForceCollect::No) {
 159                 Ok(None) => break,
 160                 Ok(Some(item)) => {
 161                     if is_stmt {
 162                         items.push(Annotatable::Stmt(P(ecx.stmt_item(span, item))));
 163                     } else {
 164                         items.push(Annotatable::Item(item));
 165                     }
 166                 }
 167                 Err(mut err) => {
 168                     err.emit();
 169                     break;
 170                 }
 171             }
 172         }
 173
 174         // fail if there have been errors emitted
 175         if ecx.sess.parse_sess.span_diagnostic.err_count() > error_count_before {
 176             ecx.struct_span_err(span, "proc-macro derive produced unparseable tokens").emit();
 177         }
 178
 179         ExpandResult::Ready(items)
 180     }
 181 }