Merge pull request #38 from TheBlueMatt/main

[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 6ea8e284a5286e1e267d01082ab6e8a0967007b6..13c3b0ed0c2b7b3b00b4af8e58728a117614d6cb 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -723,6 +723,14 @@ impl FullLibraryAST {
 fn initial_clonable_types() -> HashSet<String> {
        let mut res = HashSet::new();
        res.insert("crate::c_types::u5".to_owned());
+       res.insert("crate::c_types::ThirtyTwoBytes".to_owned());
+       res.insert("crate::c_types::PublicKey".to_owned());
+       res.insert("crate::c_types::Transaction".to_owned());
+       res.insert("crate::c_types::TxOut".to_owned());
+       res.insert("crate::c_types::Signature".to_owned());
+       res.insert("crate::c_types::RecoverableSignature".to_owned());
+       res.insert("crate::c_types::Secp256k1Error".to_owned());
+       res.insert("crate::c_types::IOError".to_owned());
        res
 }
 
@@ -850,9 +858,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                if self.is_primitive(ty) { return true; }
                match ty {
                        "()" => true,
-                       "crate::c_types::Signature" => true,
-                       "crate::c_types::RecoverableSignature" => true,
-                       "crate::c_types::TxOut" => true,
                        _ => false,
                }
        }
@@ -1258,7 +1263,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
        }
        /// Returns true if the path is a "transparent" container, ie an Option or a container which does
        /// not require a generated continer class.
-       fn is_path_transparent_container(&self, full_path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
+       pub fn is_path_transparent_container(&self, full_path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
                let inner_iter = match &full_path.segments.last().unwrap().arguments {
                        syn::PathArguments::None => return false,
                        syn::PathArguments::AngleBracketed(args) => args.args.iter().map(|arg| {
@@ -1285,16 +1290,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                                        (").into(), Err(mut e) => crate::c_types::CResultTempl::err(".to_string(), "e".to_string())],
                                                ").into() }", ContainerPrefixLocation::PerConv))
                        },
-                       "Vec" if !is_ref => {
-                               Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv))
-                       },
                        "Vec" => {
-                               // We should only get here if the single contained has an inner
-                               assert!(self.c_type_has_inner(single_contained.unwrap()));
-                               Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "*item".to_string())], "); }", ContainerPrefixLocation::PerConv))
+                               if is_ref {
+                                       // We should only get here if the single contained has an inner
+                                       assert!(self.c_type_has_inner(single_contained.unwrap()));
+                               }
+                               Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv))
                        },
                        "Slice" => {
-                               Some(("Vec::new(); for item in ", vec![(format!(".iter() {{ local_{}.push(", var_name), "*item".to_string())], "); }", ContainerPrefixLocation::PerConv))
+                               Some(("Vec::new(); for item in ", vec![(format!(".iter() {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv))
                        },
                        "Option" => {
                                let contained_struct = if let Some(syn::Type::Path(p)) = single_contained {