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         _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),
 125                 _ => unreachable!(),
 126             };
 127             TokenStream::token_alone(token::Interpolated(Lrc::new(nt)), DUMMY_SP)
 128         } else {
 129             item.to_tokens()
 130         };
 131
 132         let stream = {
 133             let _timer =
 134                 ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
 135                     recorder.record_arg_with_span(ecx.expansion_descr(), span);
 136                 });
 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,
 142                 Err(e) => {
 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));
 146                     }
 147                     err.emit();
 148                     return ExpandResult::Ready(vec![]);
 149                 }
 150             }
 151         };
 152
 153         let error_count_before = ecx.sess.parse_sess.span_diagnostic.err_count();
 154         let mut parser =
 155             rustc_parse::stream_to_parser(&ecx.sess.parse_sess, stream, Some("proc-macro derive"));
 156         let mut items = vec![];
 157
 158         loop {
 159             match parser.parse_item(ForceCollect::No) {
 160                 Ok(None) => break,
 161                 Ok(Some(item)) => {
 162                     if is_stmt {
 163                         items.push(Annotatable::Stmt(P(ecx.stmt_item(span, item))));
 164                     } else {
 165                         items.push(Annotatable::Item(item));
 166                     }
 167                 }
 168                 Err(mut err) => {
 169                     err.emit();
 170                     break;
 171                 }
 172             }
 173         }
 174
 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();
 178         }
 179
 180         ExpandResult::Ready(items)
 181     }
 182 }