Merge FreeFunctions trait into Server trait

And rename FreeFunctions struct to Methods.

compiler/rustc_expand/src/proc_macro_server.rs

@@ -431,8 +431,6 @@ impl ToInternal<rustc_errors::Level> for Level {
     }
 }
 
-pub(crate) struct FreeFunctions;
-
 pub(crate) struct Rustc<'a, 'b> {
     ecx: &'a mut ExtCtxt<'b>,
     def_site: Span,
@@ -461,13 +459,28 @@ impl<'a, 'b> Rustc<'a, 'b> {
 }
 
 impl server::Types for Rustc<'_, '_> {
-    type FreeFunctions = FreeFunctions;
     type TokenStream = TokenStream;
     type Span = Span;
     type Symbol = Symbol;
 }
 
-impl server::FreeFunctions for Rustc<'_, '_> {
+impl server::Server for Rustc<'_, '_> {
+    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
+        ExpnGlobals {
+            def_site: self.def_site,
+            call_site: self.call_site,
+            mixed_site: self.mixed_site,
+        }
+    }
+
+    fn intern_symbol(string: &str) -> Self::Symbol {
+        Symbol::intern(string)
+    }
+
+    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+        f(symbol.as_str())
+    }
+
     fn injected_env_var(&mut self, var: &str) -> Option<String> {
         self.ecx.sess.opts.logical_env.get(var).cloned()
     }
@@ -843,21 +856,3 @@ impl server::FreeFunctions for Rustc<'_, '_> {
         if rustc_lexer::is_ident(sym.as_str()) { Ok(sym) } else { Err(()) }
     }
 }
-
-impl server::Server for Rustc<'_, '_> {
-    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-        ExpnGlobals {
-            def_site: self.def_site,
-            call_site: self.call_site,
-            mixed_site: self.mixed_site,
-        }
-    }
-
-    fn intern_symbol(string: &str) -> Self::Symbol {
-        Symbol::intern(string)
-    }
-
-    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-        f(symbol.as_str())
-    }
-}

library/proc_macro/src/bridge/client.rs

@@ -25,7 +25,7 @@ impl !Sync for TokenStream {}
 // Forward `Drop::drop` to the inherent `drop` method.
 impl Drop for TokenStream {
     fn drop(&mut self) {
-        FreeFunctions::tt_drop(TokenStream { handle: self.handle });
+        Methods::tt_drop(TokenStream { handle: self.handle });
     }
 }
 
@@ -75,7 +75,7 @@ impl<S> Decode<'_, '_, S> for Span {
 
 impl Clone for TokenStream {
     fn clone(&self) -> Self {
-        FreeFunctions::tt_clone(self)
+        Methods::tt_clone(self)
     }
 }
 
@@ -95,21 +95,21 @@ impl Span {
 
 impl fmt::Debug for Span {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&FreeFunctions::span_debug(*self))
+        f.write_str(&Methods::span_debug(*self))
     }
 }
 
-pub(crate) use super::FreeFunctions;
+pub(crate) use super::Methods;
 pub(crate) use super::symbol::Symbol;
 
 macro_rules! define_client_side {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
-        impl FreeFunctions {
+        impl Methods {
             $(pub(crate) fn $method($($arg: $arg_ty),*) $(-> $ret_ty)? {
                 Bridge::with(|bridge| {
                     let mut buf = bridge.cached_buffer.take();

library/proc_macro/src/bridge/mod.rs

@@ -21,7 +21,7 @@ use crate::{Delimiter, Level, Spacing};
 /// `with_api!(MySelf, my_self, my_macro)` expands to:
 /// ```rust,ignore (pseudo-code)
 /// my_macro! {
-///     FreeFunctions {
+///     Methods {
 ///         // ...
 ///         fn lit_character(ch: char) -> MySelf::Literal;
 ///         // ...
@@ -49,7 +49,7 @@ use crate::{Delimiter, Level, Spacing};
 macro_rules! with_api {
     ($S:ident, $self:ident, $m:ident) => {
         $m! {
-            FreeFunctions {
+            Methods {
                 fn injected_env_var(var: &str) -> Option<String>;
                 fn track_env_var(var: &str, value: Option<&str>);
                 fn track_path(path: &str);
@@ -103,7 +103,7 @@ macro_rules! with_api {
     };
 }
 
-pub(crate) struct FreeFunctions;
+pub(crate) struct Methods;
 
 #[allow(unsafe_code)]
 mod arena;
@@ -158,7 +158,7 @@ mod api_tags {
 
     macro_rules! declare_tags {
         (
-            FreeFunctions {
+            Methods {
                 $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
             },
             $($name:ident),* $(,)?

library/proc_macro/src/bridge/server.rs

@@ -54,65 +54,59 @@ impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>> for Marked<S::Span, c
 }
 
 pub trait Types {
-    type FreeFunctions: 'static;
     type TokenStream: 'static + Clone;
     type Span: 'static + Copy + Eq + Hash;
     type Symbol: 'static;
 }
 
 macro_rules! declare_server_traits {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
-        pub trait FreeFunctions: Types {
-            $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
-        }
-
-        pub trait Server: Types + FreeFunctions {
+        pub trait Server: Types {
             fn globals(&mut self) -> ExpnGlobals<Self::Span>;
 
             /// Intern a symbol received from RPC
             fn intern_symbol(ident: &str) -> Self::Symbol;
 
             /// Recover the string value of a symbol, and invoke a callback with it.
             fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str));
+
+            $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
         }
     }
 }
 with_api!(Self, self_, declare_server_traits);
 
 pub(super) struct MarkedTypes<S: Types>(S);
 
-impl<S: Server> Server for MarkedTypes<S> {
-    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-        <_>::mark(Server::globals(&mut self.0))
-    }
-    fn intern_symbol(ident: &str) -> Self::Symbol {
-        <_>::mark(S::intern_symbol(ident))
-    }
-    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-        S::with_symbol_string(symbol.unmark(), f)
-    }
-}
-
 macro_rules! define_mark_types_impls {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
         impl<S: Types> Types for MarkedTypes<S> {
-            type FreeFunctions = Marked<S::FreeFunctions, client::FreeFunctions>;
             $(type $name = Marked<S::$name, client::$name>;)*
         }
 
-        impl<S: FreeFunctions> FreeFunctions for MarkedTypes<S> {
+        impl<S: Server> Server for MarkedTypes<S> {
+            fn globals(&mut self) -> ExpnGlobals<Self::Span> {
+                <_>::mark(Server::globals(&mut self.0))
+            }
+            fn intern_symbol(ident: &str) -> Self::Symbol {
+                <_>::mark(S::intern_symbol(ident))
+            }
+            fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+                S::with_symbol_string(symbol.unmark(), f)
+            }
+
             $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)? {
-                <_>::mark(FreeFunctions::$method(&mut self.0, $($arg.unmark()),*))
+                <_>::mark(S::$method(&mut self.0, $($arg.unmark()),*))
             })*
         }
     }
@@ -126,22 +120,20 @@ struct Dispatcher<S: Types> {
 
 macro_rules! define_dispatcher_impl {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
         // FIXME(eddyb) `pub` only for `ExecutionStrategy` below.
         pub trait DispatcherTrait {
             // HACK(eddyb) these are here to allow `Self::$name` to work below.
-            type FreeFunctions;
             $(type $name;)*
 
             fn dispatch(&mut self, buf: Buffer) -> Buffer;
         }
 
         impl<S: Server> DispatcherTrait for Dispatcher<MarkedTypes<S>> {
-            type FreeFunctions = <MarkedTypes<S> as Types>::FreeFunctions;
             $(type $name = <MarkedTypes<S> as Types>::$name;)*
 
             fn dispatch(&mut self, mut buf: Buffer) -> Buffer {
@@ -152,7 +144,7 @@ macro_rules! define_dispatcher_impl {
                     $(api_tags::Method::$method => {
                         let mut call_method = || {
                             $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
-                            FreeFunctions::$method(server, $($arg),*)
+                            server.$method($($arg),*)
                         };
                         // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
                         // If client and server happen to use the same `std`,

library/proc_macro/src/bridge/symbol.rs

@@ -46,7 +46,7 @@ impl Symbol {
         if string.is_ascii() {
             Err(())
         } else {
-            client::FreeFunctions::symbol_normalize_and_validate_ident(string)
+            client::Methods::symbol_normalize_and_validate_ident(string)
         }
         .unwrap_or_else(|_| panic!("`{:?}` is not a valid identifier", string))
     }

library/proc_macro/src/diagnostic.rs

@@ -170,6 +170,6 @@ impl Diagnostic {
             }
         }
 
-        crate::bridge::client::FreeFunctions::emit_diagnostic(to_internal(self));
+        crate::bridge::client::Methods::emit_diagnostic(to_internal(self));
     }
 }