From bb4115effd4b8c7f5f597e8dea257347cdcddc51 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 1 Oct 2020 18:42:33 -0400 Subject: [PATCH] [bindings] Avoid guessing whether resolved type is a ref in blocks In some cases, things which are a Rust Reference (ie slices), we may still want to map them as a non-reference and need to put a "mut " in front of the variable name in a function decl. This worked fine by just checking for the slice case, except that we are about to add support for type aliases, which no longer match the naive case. Instead, we can just have the types module print out the C type and check if it begins with a '&' to figure out if it is a reference. --- c-bindings-gen/src/blocks.rs | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 9e255a152..076f93731 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -113,20 +113,15 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, a syn::FnArg::Typed(arg) => { if types.skip_arg(&*arg.ty, generics) { continue; } if !arg.attrs.is_empty() { unimplemented!(); } - let mut is_ref = if let syn::Type::Reference(_) = *arg.ty { true } else { false }; - if let syn::Type::Reference(syn::TypeReference { ref elem, .. }) = *arg.ty { - if let syn::Type::Slice(_) = &**elem { - // Slices are mapped to non-ref Vec types, so we want them to be mut - // letting us drain(..) the underlying Vec. - is_ref = false; - } - } + // First get the c type so that we can check if it ends up being a reference: + let mut c_type = Vec::new(); + types.write_c_type(&mut c_type, &*arg.ty, generics, false); match &*arg.pat { syn::Pat::Ident(ident) => { if !ident.attrs.is_empty() || ident.subpat.is_some() { unimplemented!(); } - write!(w, "{}{}{}: ", if first_arg { "" } else { ", " }, if is_ref || !fn_decl { "" } else { "mut " }, ident.ident).unwrap(); + write!(w, "{}{}{}: ", if first_arg { "" } else { ", " }, if !fn_decl || c_type[0] == '&' as u8 || c_type[0] == '*' as u8 { "" } else { "mut " }, ident.ident).unwrap(); first_arg = false; }, syn::Pat::Wild(wild) => { @@ -136,7 +131,7 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, a }, _ => unimplemented!(), } - types.write_c_type(w, &*arg.ty, generics, false); + w.write(&c_type).unwrap(); } } } -- 2.39.5