Merge pull request #1441 from google/minisyn-inputs

Minisyn to wrap inputs

Author: adetaylor

engine/src/conversion/analysis/abstract_types.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use indexmap::map::IndexMap as HashMap;
-use syn::{punctuated::Punctuated, token::Comma, FnArg};
+use syn::{punctuated::Punctuated, token::Comma};
 
 use super::{
     fun::{
@@ -16,11 +16,14 @@ use super::{
     },
     pod::PodAnalysis,
 };
-use crate::conversion::{
-    analysis::{depth_first::fields_and_bases_first, fun::ReceiverMutability},
-    api::{ApiName, TypeKind},
-    error_reporter::{convert_apis, convert_item_apis},
-    ConvertErrorFromCpp, CppEffectiveName,
+use crate::{
+    conversion::{
+        analysis::{depth_first::fields_and_bases_first, fun::ReceiverMutability},
+        api::{ApiName, TypeKind},
+        error_reporter::{convert_apis, convert_item_apis},
+        ConvertErrorFromCpp, CppEffectiveName,
+    },
+    minisyn::FnArg,
 };
 use crate::{
     conversion::{api::Api, apivec::ApiVec},
@@ -47,7 +50,7 @@ impl Signature {
                 .iter()
                 .skip(1) // skip `this` implicit argument
                 .filter_map(|p| {
-                    if let FnArg::Typed(t) = p {
+                    if let syn::FnArg::Typed(t) = &p.0 {
                         Some((*t.ty).clone())
                     } else {
                         None

engine/src/conversion/analysis/fun/mod.rs

@@ -29,7 +29,7 @@ use crate::{
         CppEffectiveName, CppOriginalName,
     },
     known_types::known_types,
-    minisyn::minisynize_punctuated,
+    minisyn::{minisynize_punctuated, FnArg},
     types::validate_ident_ok_for_rust,
 };
 use indexmap::map::IndexMap as HashMap;
@@ -41,8 +41,8 @@ use itertools::Itertools;
 use proc_macro2::Span;
 use quote::quote;
 use syn::{
-    parse_quote, punctuated::Punctuated, token::Comma, FnArg, Ident, Pat, PatType, ReturnType,
-    Type, TypePath, TypePtr, TypeReference, Visibility,
+    parse_quote, punctuated::Punctuated, token::Comma, Ident, Pat, PatType, ReturnType, Type,
+    TypePath, TypePtr, TypeReference, Visibility,
 };
 
 use crate::{
@@ -1673,8 +1673,8 @@ impl<'a> FnAnalyzer<'a> {
         sophistication: TypeConversionSophistication,
         construct_into_self: bool,
     ) -> Result<(FnArg, ArgumentAnalysis), ConvertErrorFromCpp> {
-        Ok(match arg {
-            FnArg::Typed(pt) => {
+        Ok(match &arg.0 {
+            syn::FnArg::Typed(pt) => {
                 let mut pt = pt.clone();
                 let mut self_type = None;
                 let old_pat = *pt.pat;
@@ -1762,7 +1762,7 @@ impl<'a> FnAnalyzer<'a> {
                         UnsafetyNeeded::None
                     };
                 (
-                    FnArg::Typed(pt),
+                    syn::FnArg::Typed(pt).into(),
                     ArgumentAnalysis {
                         self_type,
                         name: new_pat.into(),
@@ -2367,10 +2367,10 @@ impl HasFieldsAndBases for Api<FnPrePhase2> {
 }
 
 /// Stringify a function argument for diagnostics
-fn describe_arg(arg: &FnArg) -> String {
+fn describe_arg(arg: &syn::FnArg) -> String {
     match arg {
-        FnArg::Receiver(_) => "the function receiver (this/self paramter)".into(),
-        FnArg::Typed(PatType { pat, .. }) => match pat.as_ref() {
+        syn::FnArg::Receiver(_) => "the function receiver (this/self paramter)".into(),
+        syn::FnArg::Typed(PatType { pat, .. }) => match pat.as_ref() {
             Pat::Ident(pti) => pti.ident.to_string(),
             _ => "another argument we don't know how to describe".into(),
         },

engine/src/conversion/codegen_rs/fun_codegen.rs

@@ -16,13 +16,13 @@ use syn::{
     parse_quote,
     punctuated::Punctuated,
     token::{Comma, Unsafe},
-    Attribute, FnArg, ForeignItem, Ident, ImplItem, Item, ReturnType,
+    Attribute, ForeignItem, Ident, ImplItem, Item, ReturnType,
 };
 
 use super::{
     function_wrapper_rs::RustParamConversion,
     maybe_unsafes_to_tokens,
-    unqualify::{unqualify_params, unqualify_ret_type},
+    unqualify::{unqualify_params_minisyn, unqualify_ret_type},
     ImplBlockDetails, MaybeUnsafeStmt, RsCodegenResult, TraitImplBlockDetails, Use,
 };
 use crate::{
@@ -33,7 +33,7 @@ use crate::{
         },
         api::UnsafetyNeeded,
     },
-    minisyn::minisynize_vec,
+    minisyn::{minisynize_vec, FnArg},
     types::{Namespace, QualifiedName},
 };
 use crate::{
@@ -193,7 +193,7 @@ pub(super) fn gen_function(
     // well-known types should be unqualified already (e.g. just UniquePtr)
     // and the following code will act to unqualify only those types
     // which the user has declared.
-    let params = unqualify_params(params);
+    let params = unqualify_params_minisyn(params);
     let ret_type = unqualify_ret_type(ret_type.into_owned());
     // And we need to make an attribute for the namespace that the function
     // itself is in.

engine/src/conversion/codegen_rs/lifetime.rs

@@ -10,15 +10,16 @@ use crate::{
         function_wrapper::{RustConversionType, TypeConversionPolicy},
         ArgumentAnalysis, ReceiverMutability,
     },
+    minisyn::FnArg,
     types::QualifiedName,
 };
 use indexmap::set::IndexSet as HashSet;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 use std::borrow::Cow;
 use syn::{
-    parse_quote, punctuated::Punctuated, token::Comma, FnArg, GenericArgument, PatType, Path,
-    PathSegment, ReturnType, Type, TypePath, TypeReference,
+    parse_quote, punctuated::Punctuated, token::Comma, GenericArgument, PatType, Path, PathSegment,
+    ReturnType, Type, TypePath, TypeReference,
 };
 
 /// Function which can add explicit lifetime parameters to function signatures
@@ -116,8 +117,9 @@ pub(crate) fn add_explicit_lifetime_if_necessary<'r>(
         }
         None => (None, params, ret_type),
         Some(new_return_type) => {
-            for FnArg::Typed(PatType { ty, .. }) | FnArg::Receiver(syn::Receiver { ty, .. }) in
-                params.iter_mut()
+            for syn::FnArg::Typed(PatType { ty, .. })
+            | syn::FnArg::Receiver(syn::Receiver { ty, .. }) in
+                params.iter_mut().map(|minifnarg| &mut minifnarg.0)
             {
                 match ty.as_mut() {
                     Type::Path(TypePath {
@@ -139,8 +141,8 @@ fn reference_parameter_is_non_pod_reference(
     params: &Punctuated<FnArg, Comma>,
     non_pod_types: &HashSet<QualifiedName>,
 ) -> bool {
-    params.iter().any(|param| match param {
-        FnArg::Typed(PatType { ty, .. }) => match ty.as_ref() {
+    params.iter().any(|param| match &param.0 {
+        syn::FnArg::Typed(PatType { ty, .. }) => match ty.as_ref() {
             Type::Reference(TypeReference { elem, .. }) => match elem.as_ref() {
                 Type::Path(typ) => {
                     let qn = QualifiedName::from_type_path(typ);

engine/src/conversion/codegen_rs/unqualify.rs

@@ -7,10 +7,12 @@
 // except according to those terms.
 
 use syn::{
-    parse_quote, punctuated::Punctuated, FnArg, GenericArgument, PathArguments, PathSegment,
-    ReturnType, Token, Type, TypePath,
+    parse_quote, punctuated::Punctuated, GenericArgument, PathArguments, PathSegment, ReturnType,
+    Token, Type, TypePath,
 };
 
+use crate::minisyn::FnArg;
+
 fn unqualify_type_path(typ: TypePath) -> TypePath {
     // If we've still got more than one
     // path segment then this is referring to a type within
@@ -76,15 +78,31 @@ pub(crate) fn unqualify_ret_type(ret_type: ReturnType) -> ReturnType {
     }
 }
 
-pub(crate) fn unqualify_params(
+pub(crate) fn unqualify_params_minisyn(
     params: Punctuated<FnArg, Token![,]>,
 ) -> Punctuated<FnArg, Token![,]> {
+    params
+        .into_iter()
+        .map(|p| match p.0 {
+            syn::FnArg::Typed(mut pt) => {
+                pt.ty = unqualify_boxed_type(pt.ty);
+                syn::FnArg::Typed(pt)
+            }
+            _ => p.0,
+        })
+        .map(FnArg)
+        .collect()
+}
+
+pub(crate) fn unqualify_params(
+    params: Punctuated<syn::FnArg, Token![,]>,
+) -> Punctuated<syn::FnArg, Token![,]> {
     params
         .into_iter()
         .map(|p| match p {
-            FnArg::Typed(mut pt) => {
+            syn::FnArg::Typed(mut pt) => {
                 pt.ty = unqualify_boxed_type(pt.ty);
-                FnArg::Typed(pt)
+                syn::FnArg::Typed(pt)
             }
             _ => p,
         })