Merge pull request #39 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 c21572f670a378bbcd21bdd24216584714521563..d19897d3bd653784fd27a22ba9d038289bffd19f 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -890,6 +890,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "std::io::Error" => Some("crate::c_types::IOError"),
 
                        "bech32::u5" => Some("crate::c_types::u5"),
+                       "core::num::NonZeroU8" => Some("u8"),
 
                        "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
                                => Some("crate::c_types::PublicKey"),
@@ -910,6 +911,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "bitcoin::blockdata::block::BlockHeader" if is_ref  => Some("*const [u8; 80]"),
                        "bitcoin::blockdata::block::Block" if is_ref  => Some("crate::c_types::u8slice"),
 
+                       "bitcoin::hash_types::PubkeyHash"|"bitcoin::hash_types::WPubkeyHash"|"bitcoin::hash_types::ScriptHash"
+                               if is_ref => Some("*const [u8; 20]"),
+                       "bitcoin::hash_types::WScriptHash"
+                               if is_ref => Some("*const [u8; 32]"),
+
                        // Newtypes that we just expose in their original form.
                        "bitcoin::hash_types::Txid"|"bitcoin::hash_types::BlockHash"|"bitcoin_hashes::sha256::Hash"
                                if is_ref  => Some("*const [u8; 32]"),
@@ -963,6 +969,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("),
 
                        "bech32::u5" => Some(""),
+                       "core::num::NonZeroU8" => Some("core::num::NonZeroU8::new("),
 
                        "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
                                if is_ref => Some("&"),
@@ -984,6 +991,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "bitcoin::blockdata::block::BlockHeader" => Some("&::bitcoin::consensus::encode::deserialize(unsafe { &*"),
                        "bitcoin::blockdata::block::Block" if is_ref => Some("&::bitcoin::consensus::encode::deserialize("),
 
+                       "bitcoin::hash_types::PubkeyHash" if is_ref =>
+                               Some("&bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(unsafe { *"),
+                       "bitcoin::hash_types::WPubkeyHash" if is_ref =>
+                               Some("&bitcoin::hash_types::WPubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(unsafe { *"),
+                       "bitcoin::hash_types::ScriptHash" if is_ref =>
+                               Some("&bitcoin::hash_types::ScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(unsafe { *"),
+                       "bitcoin::hash_types::WScriptHash" if is_ref =>
+                               Some("&bitcoin::hash_types::WScriptHash::from_hash(bitcoin::hashes::Hash::from_inner(unsafe { *"),
+
                        // Newtypes that we just expose in their original form.
                        "bitcoin::hash_types::Txid" if is_ref => Some("&::bitcoin::hash_types::Txid::from_slice(&unsafe { &*"),
                        "bitcoin::hash_types::Txid" if !is_ref => Some("::bitcoin::hash_types::Txid::from_slice(&"),
@@ -1028,6 +1044,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "std::time::SystemTime" => Some("))"),
 
                        "bech32::u5" => Some(".into()"),
+                       "core::num::NonZeroU8" => Some(").expect(\"Value must be non-zero\")"),
 
                        "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
                                => Some(".into_rust()"),
@@ -1045,6 +1062,10 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "bitcoin::blockdata::block::BlockHeader" => Some(" }).unwrap()"),
                        "bitcoin::blockdata::block::Block" => Some(".to_slice()).unwrap()"),
 
+                       "bitcoin::hash_types::PubkeyHash"|"bitcoin::hash_types::WPubkeyHash"|
+                       "bitcoin::hash_types::ScriptHash"|"bitcoin::hash_types::WScriptHash"
+                               if is_ref => Some(" }.clone()))"),
+
                        // Newtypes that we just expose in their original form.
                        "bitcoin::hash_types::Txid" if is_ref => Some(" }[..]).unwrap()"),
                        "bitcoin::hash_types::Txid" => Some(".data[..]).unwrap()"),
@@ -1263,7 +1284,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| {
@@ -1290,16 +1311,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 {