Consistently use ExternFn's Deref impl

Author: dtolnay

gen/src/write.rs

@@ -95,7 +95,7 @@ fn write_data_structures<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) {
     let mut methods_for_type = Map::new();
     for api in apis {
         if let Api::CxxFunction(efn) | Api::RustFunction(efn) = api {
-            if let Some(receiver) = &efn.sig.receiver {
+            if let Some(receiver) = &efn.receiver {
                 methods_for_type
                     .entry(&receiver.ty.rust)
                     .or_insert_with(Vec::new)
@@ -986,7 +986,7 @@ fn write_rust_function_decl_impl(
 
 fn write_rust_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
     out.set_namespace(&efn.name.namespace);
-    let local_name = match &efn.sig.receiver {
+    let local_name = match &efn.receiver {
         None => efn.name.cxx.to_string(),
         Some(receiver) => format!(
             "{}::{}",

macro/src/expand.rs

@@ -650,7 +650,7 @@ fn expand_cxx_function_shim(efn: &ExternFn, types: &Types) -> TokenStream {
         }
     };
     let mut expr;
-    if efn.throws && efn.sig.ret.is_none() {
+    if efn.throws && efn.ret.is_none() {
         expr = call;
     } else {
         expr = match &efn.ret {
@@ -729,11 +729,11 @@ fn expand_cxx_function_shim(efn: &ExternFn, types: &Types) -> TokenStream {
     }
     let dispatch = quote_spanned!(span=> unsafe { #setup #expr });
     let visibility = efn.visibility;
-    let unsafety = &efn.sig.unsafety;
-    let fn_token = efn.sig.fn_token;
+    let unsafety = &efn.unsafety;
+    let fn_token = efn.fn_token;
     let ident = &efn.name.rust;
     let generics = &efn.generics;
-    let arg_list = quote_spanned!(efn.sig.paren_token.span=> (#(#all_args,)*));
+    let arg_list = quote_spanned!(efn.paren_token.span=> (#(#all_args,)*));
     let fn_body = quote_spanned!(span=> {
         #UnsafeExtern extern "C" {
             #decl

syntax/check.rs

@@ -427,7 +427,7 @@ fn check_api_fn(cx: &mut Check, efn: &ExternFn) {
         }
     }
 
-    check_generics(cx, &efn.sig.generics);
+    check_generics(cx, &efn.generics);
 
     if let Some(receiver) = &efn.receiver {
         let ref span = span_for_receiver_error(receiver);
@@ -472,7 +472,7 @@ fn check_api_fn(cx: &mut Check, efn: &ExternFn) {
                 );
             }
         } else if let Type::Ptr(_) = arg.ty {
-            if efn.sig.unsafety.is_none() {
+            if efn.unsafety.is_none() {
                 cx.error(
                     arg,
                     "pointer argument requires that the function be marked unsafe",
@@ -540,7 +540,7 @@ fn check_api_impl(cx: &mut Check, imp: &Impl) {
 }
 
 fn check_mut_return_restriction(cx: &mut Check, efn: &ExternFn) {
-    if efn.sig.unsafety.is_some() {
+    if efn.unsafety.is_some() {
         // Unrestricted as long as the function is made unsafe-to-call.
         return;
     }

syntax/tokens.rs

@@ -213,7 +213,7 @@ impl ToTokens for ExternFn {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         // Notional token range for error reporting purposes.
         self.unsafety.to_tokens(tokens);
-        self.sig.fn_token.to_tokens(tokens);
+        self.fn_token.to_tokens(tokens);
         self.semi_token.to_tokens(tokens);
     }
 }