library/proc_macro/src/bridge/server.rs

   1 //! Server-side traits.
   2
   3 use super::*;
   4
   5 // FIXME(eddyb) generate the definition of `HandleStore` in `server.rs`.
   6 use super::client::HandleStore;
   7
   8 /// Declare an associated item of one of the traits below, optionally
   9 /// adjusting it (i.e., adding bounds to types and default bodies to methods).
  10 macro_rules! associated_item {
  11     (type FreeFunctions) =>
  12         (type FreeFunctions: 'static;);
  13     (type TokenStream) =>
  14         (type TokenStream: 'static + Clone;);
  15     (type TokenStreamBuilder) =>
  16         (type TokenStreamBuilder: 'static;);
  17     (type TokenStreamIter) =>
  18         (type TokenStreamIter: 'static + Clone;);
  19     (type Group) =>
  20         (type Group: 'static + Clone;);
  21     (type Punct) =>
  22         (type Punct: 'static + Copy + Eq + Hash;);
  23     (type Ident) =>
  24         (type Ident: 'static + Copy + Eq + Hash;);
  25     (type Literal) =>
  26         (type Literal: 'static + Clone;);
  27     (type SourceFile) =>
  28         (type SourceFile: 'static + Clone;);
  29     (type MultiSpan) =>
  30         (type MultiSpan: 'static;);
  31     (type Diagnostic) =>
  32         (type Diagnostic: 'static;);
  33     (type Span) =>
  34         (type Span: 'static + Copy + Eq + Hash;);
  35     (fn drop(&mut self, $arg:ident: $arg_ty:ty)) =>
  36         (fn drop(&mut self, $arg: $arg_ty) { mem::drop($arg) });
  37     (fn clone(&mut self, $arg:ident: $arg_ty:ty) -> $ret_ty:ty) =>
  38         (fn clone(&mut self, $arg: $arg_ty) -> $ret_ty { $arg.clone() });
  39     ($($item:tt)*) => ($($item)*;)
  40 }
  41
  42 macro_rules! declare_server_traits {
  43     ($($name:ident {
  44         $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
  45     }),* $(,)?) => {
  46         pub trait Types {
  47             $(associated_item!(type $name);)*
  48         }
  49
  50         $(pub trait $name: Types {
  51             $(associated_item!(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?);)*
  52         })*
  53
  54         pub trait Server: Types $(+ $name)* {}
  55         impl<S: Types $(+ $name)*> Server for S {}
  56     }
  57 }
  58 with_api!(Self, self_, declare_server_traits);
  59
  60 pub(super) struct MarkedTypes<S: Types>(S);
  61
  62 macro_rules! define_mark_types_impls {
  63     ($($name:ident {
  64         $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
  65     }),* $(,)?) => {
  66         impl<S: Types> Types for MarkedTypes<S> {
  67             $(type $name = Marked<S::$name, client::$name>;)*
  68         }
  69
  70         $(impl<S: $name> $name for MarkedTypes<S> {
  71             $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)? {
  72                 <_>::mark($name::$method(&mut self.0, $($arg.unmark()),*))
  73             })*
  74         })*
  75     }
  76 }
  77 with_api!(Self, self_, define_mark_types_impls);
  78
  79 struct Dispatcher<S: Types> {
  80     handle_store: HandleStore<S>,
  81     server: S,
  82 }
  83
  84 macro_rules! define_dispatcher_impl {
  85     ($($name:ident {
  86         $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
  87     }),* $(,)?) => {
  88         // FIXME(eddyb) `pub` only for `ExecutionStrategy` below.
  89         pub trait DispatcherTrait {
  90             // HACK(eddyb) these are here to allow `Self::$name` to work below.
  91             $(type $name;)*
  92             fn dispatch(&mut self, b: Buffer<u8>) -> Buffer<u8>;
  93         }
  94
  95         impl<S: Server> DispatcherTrait for Dispatcher<MarkedTypes<S>> {
  96             $(type $name = <MarkedTypes<S> as Types>::$name;)*
  97             fn dispatch(&mut self, mut b: Buffer<u8>) -> Buffer<u8> {
  98                 let Dispatcher { handle_store, server } = self;
  99
 100                 let mut reader = &b[..];
 101                 match api_tags::Method::decode(&mut reader, &mut ()) {
 102                     $(api_tags::Method::$name(m) => match m {
 103                         $(api_tags::$name::$method => {
 104                             let mut call_method = || {
 105                                 reverse_decode!(reader, handle_store; $($arg: $arg_ty),*);
 106                                 $name::$method(server, $($arg),*)
 107                             };
 108                             // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
 109                             // If client and server happen to use the same `libstd`,
 110                             // `catch_unwind` asserts that the panic counter was 0,
 111                             // even when the closure passed to it didn't panic.
 112                             let r = if thread::panicking() {
 113                                 Ok(call_method())
 114                             } else {
 115                                 panic::catch_unwind(panic::AssertUnwindSafe(call_method))
 116                                     .map_err(PanicMessage::from)
 117                             };
 118
 119                             b.clear();
 120                             r.encode(&mut b, handle_store);
 121                         })*
 122                     }),*
 123                 }
 124                 b
 125             }
 126         }
 127     }
 128 }
 129 with_api!(Self, self_, define_dispatcher_impl);
 130
 131 pub trait ExecutionStrategy {
 132     fn run_bridge_and_client<D: Copy + Send + 'static>(
 133         &self,
 134         dispatcher: &mut impl DispatcherTrait,
 135         input: Buffer<u8>,
 136         run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
 137         client_data: D,
 138         force_show_panics: bool,
 139     ) -> Buffer<u8>;
 140 }
 141
 142 pub struct SameThread;
 143
 144 impl ExecutionStrategy for SameThread {
 145     fn run_bridge_and_client<D: Copy + Send + 'static>(
 146         &self,
 147         dispatcher: &mut impl DispatcherTrait,
 148         input: Buffer<u8>,
 149         run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
 150         client_data: D,
 151         force_show_panics: bool,
 152     ) -> Buffer<u8> {
 153         let mut dispatch = |b| dispatcher.dispatch(b);
 154
 155         run_client(
 156             Bridge { cached_buffer: input, dispatch: (&mut dispatch).into(), force_show_panics },
 157             client_data,
 158         )
 159     }
 160 }
 161
 162 // NOTE(eddyb) Two implementations are provided, the second one is a bit
 163 // faster but neither is anywhere near as fast as same-thread execution.
 164
 165 pub struct CrossThread1;
 166
 167 impl ExecutionStrategy for CrossThread1 {
 168     fn run_bridge_and_client<D: Copy + Send + 'static>(
 169         &self,
 170         dispatcher: &mut impl DispatcherTrait,
 171         input: Buffer<u8>,
 172         run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
 173         client_data: D,
 174         force_show_panics: bool,
 175     ) -> Buffer<u8> {
 176         use std::sync::mpsc::channel;
 177
 178         let (req_tx, req_rx) = channel();
 179         let (res_tx, res_rx) = channel();
 180
 181         let join_handle = thread::spawn(move || {
 182             let mut dispatch = |b| {
 183                 req_tx.send(b).unwrap();
 184                 res_rx.recv().unwrap()
 185             };
 186
 187             run_client(
 188                 Bridge {
 189                     cached_buffer: input,
 190                     dispatch: (&mut dispatch).into(),
 191                     force_show_panics,
 192                 },
 193                 client_data,
 194             )
 195         });
 196
 197         for b in req_rx {
 198             res_tx.send(dispatcher.dispatch(b)).unwrap();
 199         }
 200
 201         join_handle.join().unwrap()
 202     }
 203 }
 204
 205 pub struct CrossThread2;
 206
 207 impl ExecutionStrategy for CrossThread2 {
 208     fn run_bridge_and_client<D: Copy + Send + 'static>(
 209         &self,
 210         dispatcher: &mut impl DispatcherTrait,
 211         input: Buffer<u8>,
 212         run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
 213         client_data: D,
 214         force_show_panics: bool,
 215     ) -> Buffer<u8> {
 216         use std::sync::{Arc, Mutex};
 217
 218         enum State<T> {
 219             Req(T),
 220             Res(T),
 221         }
 222
 223         let mut state = Arc::new(Mutex::new(State::Res(Buffer::new())));
 224
 225         let server_thread = thread::current();
 226         let state2 = state.clone();
 227         let join_handle = thread::spawn(move || {
 228             let mut dispatch = |b| {
 229                 *state2.lock().unwrap() = State::Req(b);
 230                 server_thread.unpark();
 231                 loop {
 232                     thread::park();
 233                     if let State::Res(b) = &mut *state2.lock().unwrap() {
 234                         break b.take();
 235                     }
 236                 }
 237             };
 238
 239             let r = run_client(
 240                 Bridge {
 241                     cached_buffer: input,
 242                     dispatch: (&mut dispatch).into(),
 243                     force_show_panics,
 244                 },
 245                 client_data,
 246             );
 247
 248             // Wake up the server so it can exit the dispatch loop.
 249             drop(state2);
 250             server_thread.unpark();
 251
 252             r
 253         });
 254
 255         // Check whether `state2` was dropped, to know when to stop.
 256         while Arc::get_mut(&mut state).is_none() {
 257             thread::park();
 258             let mut b = match &mut *state.lock().unwrap() {
 259                 State::Req(b) => b.take(),
 260                 _ => continue,
 261             };
 262             b = dispatcher.dispatch(b.take());
 263             *state.lock().unwrap() = State::Res(b);
 264             join_handle.thread().unpark();
 265         }
 266
 267         join_handle.join().unwrap()
 268     }
 269 }
 270
 271 fn run_server<
 272     S: Server,
 273     I: Encode<HandleStore<MarkedTypes<S>>>,
 274     O: for<'a, 's> DecodeMut<'a, 's, HandleStore<MarkedTypes<S>>>,
 275     D: Copy + Send + 'static,
 276 >(
 277     strategy: &impl ExecutionStrategy,
 278     handle_counters: &'static client::HandleCounters,
 279     server: S,
 280     input: I,
 281     run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
 282     client_data: D,
 283     force_show_panics: bool,
 284 ) -> Result<O, PanicMessage> {
 285     let mut dispatcher =
 286         Dispatcher { handle_store: HandleStore::new(handle_counters), server: MarkedTypes(server) };
 287
 288     let mut b = Buffer::new();
 289     input.encode(&mut b, &mut dispatcher.handle_store);
 290
 291     b = strategy.run_bridge_and_client(
 292         &mut dispatcher,
 293         b,
 294         run_client,
 295         client_data,
 296         force_show_panics,
 297     );
 298
 299     Result::decode(&mut &b[..], &mut dispatcher.handle_store)
 300 }
 301
 302 impl client::Client<fn(crate::TokenStream) -> crate::TokenStream> {
 303     pub fn run<S: Server>(
 304         &self,
 305         strategy: &impl ExecutionStrategy,
 306         server: S,
 307         input: S::TokenStream,
 308         force_show_panics: bool,
 309     ) -> Result<S::TokenStream, PanicMessage> {
 310         let client::Client { get_handle_counters, run, f } = *self;
 311         run_server(
 312             strategy,
 313             get_handle_counters(),
 314             server,
 315             <MarkedTypes<S> as Types>::TokenStream::mark(input),
 316             run,
 317             f,
 318             force_show_panics,
 319         )
 320         .map(<MarkedTypes<S> as Types>::TokenStream::unmark)
 321     }
 322 }
 323
 324 impl client::Client<fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream> {
 325     pub fn run<S: Server>(
 326         &self,
 327         strategy: &impl ExecutionStrategy,
 328         server: S,
 329         input: S::TokenStream,
 330         input2: S::TokenStream,
 331         force_show_panics: bool,
 332     ) -> Result<S::TokenStream, PanicMessage> {
 333         let client::Client { get_handle_counters, run, f } = *self;
 334         run_server(
 335             strategy,
 336             get_handle_counters(),
 337             server,
 338             (
 339                 <MarkedTypes<S> as Types>::TokenStream::mark(input),
 340                 <MarkedTypes<S> as Types>::TokenStream::mark(input2),
 341             ),
 342             run,
 343             f,
 344             force_show_panics,
 345         )
 346         .map(<MarkedTypes<S> as Types>::TokenStream::unmark)
 347     }
 348 }