Allow liftime bounds on generic bounds

[ldk-c-bindings] / c-bindings-gen / src / types.rs

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 1a737d17cf11203ef1720015164d75ed7e3dd060..5fd874d3308ce04e362729d97dd13729115459e4 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -147,7 +147,7 @@ pub fn export_status(attrs: &[syn::Attribute]) -> ExportStatus {
 }
 
 pub fn assert_simple_bound(bound: &syn::TraitBound) {
-       if bound.paren_token.is_some() || bound.lifetimes.is_some() { unimplemented!(); }
+       if bound.paren_token.is_some() { unimplemented!(); }
        if let syn::TraitBoundModifier::Maybe(_) = bound.modifier { unimplemented!(); }
 }
 
@@ -1381,7 +1381,19 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        if let Some(resolved) = self.maybe_resolve_path(&p.path, generics) {
                                                if self.c_type_has_inner_from_path(&resolved) { return true; }
                                                if self.is_primitive(&resolved) { return false; }
-                                               if self.c_type_from_path(&resolved, false, false).is_some() { true } else { false }
+                                               // We want to move to using `Option_` mappings where possible rather than
+                                               // manual mappings, as it makes downstream bindings simpler and is more
+                                               // clear for users. Thus, we default to false but override for a few
+                                               // types which had mappings defined when we were avoiding the `Option_`s.
+                                               match &resolved as &str {
+                                                       "lightning::ln::PaymentSecret" => true,
+                                                       "lightning::ln::PaymentHash" => true,
+                                                       "lightning::ln::PaymentPreimage" => true,
+                                                       "lightning::ln::channelmanager::PaymentId" => true,
+                                                       "bitcoin::hash_types::BlockHash" => true,
+                                                       "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => true,
+                                                       _ => false,
+                                               }
                                        } else { unimplemented!(); }
                                },
                                syn::Type::Tuple(_) => false,
@@ -1456,7 +1468,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                                                (".is_none() { core::ptr::null_mut() } else { ".to_owned(), format!("({}.unwrap())", var_access))
                                                                ], " }", ContainerPrefixLocation::OutsideConv));
                                                }
-                                       } else if self.is_primitive(&inner_path) || self.c_type_from_path(&inner_path, false, false).is_none() {
+                                       } else if !self.is_transparent_container("Option", is_ref, [single_contained.unwrap()].iter().map(|a| *a), generics) {
                                                if self.is_primitive(&inner_path) || (!is_contained_ref && !is_ref) || only_contained_has_inner {
                                                        let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap();
                                                        return Some(("if ", vec![
@@ -1477,12 +1489,18 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                }
                                if let Some(t) = single_contained {
                                        if let syn::Type::Tuple(syn::TypeTuple { elems, .. }) = t {
-                                               assert!(elems.is_empty());
                                                let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap();
-                                               return Some(("if ", vec![
-                                                       (format!(".is_none() {{ {}::None }} else {{ {}::Some /*",
-                                                               inner_name, inner_name), format!(""))
-                                                       ], " */}", ContainerPrefixLocation::PerConv));
+                                               if elems.is_empty() {
+                                                       return Some(("if ", vec![
+                                                               (format!(".is_none() {{ {}::None }} else {{ {}::Some /* ",
+                                                                       inner_name, inner_name), format!(""))
+                                                               ], " */ }", ContainerPrefixLocation::PerConv));
+                                               } else {
+                                                       return Some(("if ", vec![
+                                                               (format!(".is_none() {{ {}::None }} else {{ {}::Some(",
+                                                                       inner_name, inner_name), format!("({}.unwrap())", var_access))
+                                                               ], ") }", ContainerPrefixLocation::PerConv));
+                                               }
                                        }
                                        if let syn::Type::Reference(syn::TypeReference { elem, .. }) = t {
                                                if let syn::Type::Slice(_) = &**elem {
@@ -2039,6 +2057,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                                        write!(w, "{}", sliceconv(false, None)).unwrap();
                                                }
                                        }
+                               } else if let syn::Type::Array(_) = &*s.elem {
+                                       write!(w, "{}", sliceconv(false, Some(".map(|a| *a)"))).unwrap();
                                } else { unimplemented!(); }
                        },
                        syn::Type::Tuple(t) => {
@@ -2391,6 +2411,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        ptr_for_ref = true;
                                        convert_container!("Slice", 1, || ty.iter());
                                        unimplemented!("convert_container should return true as container_lookup should succeed for slices");
+                               } else if let syn::Type::Array(_) = &*s.elem {
+                                       is_ref = false;
+                                       ptr_for_ref = true;
+                                       let arr_elem = [(*s.elem).clone()];
+                                       convert_container!("Slice", 1, || arr_elem.iter());
+                                       unimplemented!("convert_container should return true as container_lookup should succeed for slices");
                                } else { unimplemented!() }
                        },
                        syn::Type::Tuple(t) => {
@@ -2901,6 +2927,22 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        let mut segments = syn::punctuated::Punctuated::new();
                                        segments.push(parse_quote!(Vec<#args>));
                                        self.write_c_type_intern(w, &syn::Type::Path(syn::TypePath { qself: None, path: syn::Path { leading_colon: None, segments } }), generics, false, is_mut, ptr_for_ref, with_ref_lifetime, c_ty)
+                               } else if let syn::Type::Array(a) = &*s.elem {
+                                       if let syn::Expr::Lit(l) = &a.len {
+                                               if let syn::Lit::Int(i) = &l.lit {
+                                                       let mut buf = Vec::new();
+                                                       self.write_rust_type(&mut buf, generics, &*a.elem, false);
+                                                       let arr_ty = String::from_utf8(buf).unwrap();
+
+                                                       let arr_str = format!("[{}; {}]", arr_ty, i.base10_digits());
+                                                       let ty = self.c_type_from_path(&arr_str, false, ptr_for_ref).unwrap()
+                                                               .rsplitn(2, "::").next().unwrap();
+
+                                                       let mangled_container = format!("CVec_{}Z", ty);
+                                                       write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap();
+                                                       self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false)
+                                               } else { false }
+                                       } else { false }
                                } else { false }
                        },
                        syn::Type::Tuple(t) => {