derive: Remove dummy identifier

Author: tesaguri

oauth1-request-derive/src/lib.rs

@@ -23,7 +23,7 @@ mod util;
 use proc_macro2::{Span, TokenStream};
 use proc_macro_crate::FoundCrate;
 use proc_macro_error::{abort, abort_if_dirty, emit_error, proc_macro_error};
-use quote::quote;
+use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
 use syn::{
     parse_macro_input, parse_quote, Data, DataStruct, DeriveInput, Fields, GenericParam, Generics,
@@ -50,11 +50,6 @@ pub fn derive_oauth1_authorize(input: proc_macro::TokenStream) -> proc_macro::To
 fn expand_derive_oauth1_authorize(mut input: DeriveInput) -> TokenStream {
     let name = &input.ident;
 
-    // We assume that `dummy` does not conflict with any of call-side identifiers
-    // and (ab)use it to avoid potential name collisions.
-    let dummy = format!("_impl_ToOAuth1Request_for_{}", name);
-    let dummy = Ident::new(&dummy, Span::call_site());
-
     let krate = match proc_macro_crate::crate_name("oauth1-request").unwrap() {
         FoundCrate::Name(krate) => krate,
         // This is used in `oauth1_request`'s doctests.
@@ -105,36 +100,22 @@ fn expand_derive_oauth1_authorize(mut input: DeriveInput) -> TokenStream {
 
     abort_if_dirty();
 
-    let mut fn_generics = input.generics.clone();
-    fn_generics.params.push(parse_quote! {
-        #dummy: _oauth1_request::serializer::Serializer
-    });
-    let (fn_generics, _, _) = fn_generics.split_for_impl();
-
-    let body = MethodBody::new(&fields, &dummy);
+    let body = MethodBody::new(&fields);
 
-    quote! {
+    quote_spanned! {Span::mixed_site()=>
         const _: () = {
             extern crate #krate as _oauth1_request;
 
-            #[allow(nonstandard_style)]
-            fn #dummy #fn_generics(mut #dummy: (&#name #ty_generics, #dummy)) -> #dummy::Output
-            #where_clause
-            {
-                #body
-            }
-
             impl #impl_generics _oauth1_request::Request for #name #ty_generics
                 #where_clause
             {
-                // We do not want to mess with the signature which appears in the docs
-                // and do not want to expose the `serializer` and `S` to the macro caller,
-                // so we are separating the implementation to another function.
-                fn serialize<S>(&self, serializer: S) -> S::Output
+                // `_S`'s span resolves at call site so prefix it with underscore to avoid conflict.
+                // TODO: Use def-site hygiene once it stabilizes.
+                fn serialize<_S>(&self, mut serializer: _S) -> _S::Output
                 where
-                    S: _oauth1_request::serializer::Serializer,
+                    _S: _oauth1_request::serializer::Serializer,
                 {
-                    #dummy((self, serializer))
+                    #body
                 }
             }
         };

oauth1-request-derive/src/method_body.rs

@@ -1,4 +1,4 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::{quote, quote_spanned, ToTokens};
 use syn::spanned::Spanned;
 use syn::{Ident, PathArguments, Type};
@@ -8,19 +8,18 @@ use crate::util::OAuthParameter;
 
 pub struct MethodBody<'a> {
     fields: &'a [Field],
-    dummy: &'a Ident,
 }
 
 impl<'a> MethodBody<'a> {
-    pub fn new(fields: &'a [Field], dummy: &'a Ident) -> Self {
-        MethodBody { fields, dummy }
+    pub fn new(fields: &'a [Field]) -> Self {
+        MethodBody { fields }
     }
 }
 
 impl<'a> ToTokens for MethodBody<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let dummy = &self.dummy;
-        let (this, ser) = (quote! { #dummy.0 }, quote! { #dummy.1 });
+        let this = Ident::new("self", Span::mixed_site());
+        let ser = Ident::new("serializer", Span::mixed_site());
 
         let mut next_param = OAuthParameter::default();
         for f in self.fields {

oauth1-request-derive/tests/pass.rs

@@ -305,6 +305,16 @@ assert_expand! {
     }
 }
 
+// Just checking that this compiles.
+#[derive(oauth::Request)]
+struct Hygiene {
+    #[oauth1(fmt = serializer)]
+    a: (),
+}
+fn serializer(_: &(), _: &mut Formatter<'_>) -> fmt::Result {
+    unimplemented!();
+}
+
 // Just checking that this produces no warnings.
 #[derive(oauth::Request)]
 #[allow(nonstandard_style)]