Clean up printing of Receiver to tokens

macro/src/expand.rs

@@ -126,13 +126,7 @@ fn expand_cxx_type(ety: &ExternType) -> TokenStream {
 
 fn expand_cxx_function_decl(namespace: &Namespace, efn: &ExternFn, types: &Types) -> TokenStream {
     let ident = &efn.ident;
-    let receiver = efn.receiver.iter().map(|receiver| {
-        let ident = &receiver.ident;
-        match receiver.mutability {
-            None => quote!(_: &#ident),
-            Some(_) => quote!(_: &mut #ident),
-        }
-    });
+    let receiver = efn.receiver.iter().map(|receiver| quote!(_: #receiver));
     let args = efn.args.iter().map(|arg| {
         let ident = &arg.ident;
         let ty = expand_extern_type(&arg.ty);
@@ -169,13 +163,10 @@ fn expand_cxx_function_shim(namespace: &Namespace, efn: &ExternFn, types: &Types
     let ident = &efn.ident;
     let doc = &efn.doc;
     let decl = expand_cxx_function_decl(namespace, efn, types);
-    let receiver = efn
-        .receiver
-        .iter()
-        .map(|receiver| match receiver.mutability {
-            None => quote!(&self),
-            Some(_) => quote!(&mut self),
-        });
+    let receiver = efn.receiver.iter().map(|receiver| {
+        let mutability = receiver.mutability;
+        quote!(&#mutability self)
+    });
     let args = efn.args.iter().map(|arg| quote!(#arg));
     let all_args = receiver.chain(args);
     let ret = if efn.throws {
@@ -394,13 +385,10 @@ fn expand_rust_function_shim_impl(
     catch_unwind_label: String,
     invoke: Option<&Ident>,
 ) -> TokenStream {
-    let receiver = sig.receiver.iter().map(|receiver| {
-        let ident = &receiver.ident;
-        match receiver.mutability {
-            None => quote!(__self: &#ident),
-            Some(_) => quote!(__self: &mut #ident),
-        }
-    });
+    let receiver = sig
+        .receiver
+        .iter()
+        .map(|receiver| quote!(__self: #receiver));
     let args = sig.args.iter().map(|arg| {
         let ident = &arg.ident;
         let ty = expand_extern_type(&arg.ty);

syntax/impls.rs

@@ -184,8 +184,13 @@ impl Eq for Receiver {}
 
 impl PartialEq for Receiver {
     fn eq(&self, other: &Receiver) -> bool {
-        let Receiver { mutability, ident } = self;
         let Receiver {
+            ampersand: _,
+            mutability,
+            ident,
+        } = self;
+        let Receiver {
+            ampersand: _,
             mutability: mutability2,
             ident: ident2,
         } = other;
@@ -195,7 +200,11 @@ impl PartialEq for Receiver {
 
 impl Hash for Receiver {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        let Receiver { mutability, ident } = self;
+        let Receiver {
+            ampersand: _,
+            mutability,
+            ident,
+        } = self;
         mutability.is_some().hash(state);
         ident.hash(state);
     }

syntax/mod.rs

@@ -75,6 +75,7 @@ pub struct Var {
 }
 
 pub struct Receiver {
+    pub ampersand: Token![&],
     pub mutability: Option<Token![mut]>,
     pub ident: Ident,
 }

syntax/parse.rs

@@ -180,6 +180,7 @@ fn parse_extern_fn(foreign_fn: &ForeignItemFn, lang: Lang) -> Result<ExternFn> {
                 if let Type::Ref(reference) = ty {
                     if let Type::Ident(ident) = reference.inner {
                         receiver = Some(Receiver {
+                            ampersand: reference.ampersand,
                             mutability: reference.mutability,
                             ident,
                         });

syntax/tokens.rs

@@ -1,5 +1,5 @@
 use crate::syntax::atom::Atom::*;
-use crate::syntax::{Derive, ExternFn, Ref, Signature, Slice, Ty1, Type, Var};
+use crate::syntax::{Derive, ExternFn, Receiver, Ref, Signature, Slice, Ty1, Type, Var};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote_spanned, ToTokens};
 use syn::Token;
@@ -97,3 +97,11 @@ impl ToTokens for Signature {
         }
     }
 }
+
+impl ToTokens for Receiver {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.ampersand.to_tokens(tokens);
+        self.mutability.to_tokens(tokens);
+        self.ident.to_tokens(tokens);
+    }
+}