Handle impl blocks exist outside of the mod of the being-implemented object

[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 ced1f34b0e91c31493127c14bf8c9e7db31748ac..f9c894a23cc70ba070a0fc0e67c75d608b042453 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -65,6 +65,17 @@ pub fn path_matches_nongeneric(p: &syn::Path, exp: &[&str]) -> bool {
        true
 }
 
+pub fn string_path_to_syn_path(path: &str) -> syn::Path {
+       let mut segments = syn::punctuated::Punctuated::new();
+       for seg in path.split("::") {
+               segments.push(syn::PathSegment {
+                       ident: syn::Ident::new(seg, Span::call_site()),
+                       arguments: syn::PathArguments::None,
+               });
+       }
+       syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments }
+}
+
 #[derive(Debug, PartialEq)]
 pub enum ExportStatus {
        Export,
@@ -391,7 +402,7 @@ pub enum DeclType<'a> {
 }
 
 pub struct ImportResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> {
-       crate_name: &'mod_lifetime str,
+       pub crate_name: &'mod_lifetime str,
        dependencies: &'mod_lifetime HashSet<syn::Ident>,
        module_path: &'mod_lifetime str,
        imports: HashMap<syn::Ident, (String, syn::Path)>,
@@ -741,7 +752,7 @@ pub struct CrateTypes<'a> {
        /// Aliases from paths to some other Type
        pub type_aliases: HashMap<String, syn::Type>,
        /// Value is an alias to Key (maybe with some generics)
-       pub reverse_alias_map: HashMap<String, Vec<(syn::Path, syn::PathArguments)>>,
+       pub reverse_alias_map: HashMap<String, Vec<(String, syn::PathArguments)>>,
        /// Template continer types defined, map from mangled type name -> whether a destructor fn
        /// exists.
        ///
@@ -785,7 +796,7 @@ impl<'a> CrateTypes<'a> {
 pub struct TypeResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> {
        pub module_path: &'mod_lifetime str,
        pub crate_types: &'mod_lifetime CrateTypes<'crate_lft>,
-       types: ImportResolver<'mod_lifetime, 'crate_lft>,
+       pub types: ImportResolver<'mod_lifetime, 'crate_lft>,
 }
 
 /// Returned by write_empty_rust_val_check_suffix to indicate what type of dereferencing needs to
@@ -883,6 +894,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
                        "core::convert::Infallible" => Some("crate::c_types::NotConstructable"),
 
+                       "bitcoin::bech32::Error"|"bech32::Error"
+                               if !is_ref => Some("crate::c_types::Bech32Error"),
+                       "bitcoin::secp256k1::Error"|"secp256k1::Error"
+                               if !is_ref => Some("crate::c_types::Secp256k1Error"),
+
+                       "core::num::ParseIntError" => Some("crate::c_types::Error"),
+                       "core::str::Utf8Error" => Some("crate::c_types::Error"),
+
                        "bitcoin::bech32::u5"|"bech32::u5" => Some("crate::c_types::u5"),
                        "core::num::NonZeroU8" => Some("u8"),
 
@@ -894,8 +913,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                if is_ref  => Some("*const [u8; 32]"),
                        "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey"
                                if !is_ref => Some("crate::c_types::SecretKey"),
-                       "bitcoin::secp256k1::Error"|"secp256k1::Error"
-                               if !is_ref => Some("crate::c_types::Secp256k1Error"),
                        "bitcoin::blockdata::script::Script" if is_ref => Some("crate::c_types::u8slice"),
                        "bitcoin::blockdata::script::Script" if !is_ref => Some("crate::c_types::derived::CVec_u8Z"),
                        "bitcoin::blockdata::transaction::OutPoint" => Some("crate::lightning::chain::transaction::OutPoint"),
@@ -961,6 +978,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
                        "core::convert::Infallible" => Some("panic!(\"You must never construct a NotConstructable! : "),
 
+                       "bitcoin::bech32::Error"|"bech32::Error" if !is_ref => Some(""),
+                       "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some(""),
+
+                       "core::num::ParseIntError" => Some("u8::from_str_radix(\" a\", 10).unwrap_err() /*"),
+                       "core::str::Utf8Error" => Some("core::str::from_utf8(&[0xff]).unwrap_err() /*"),
+
                        "std::time::Duration"|"core::time::Duration" => Some("core::time::Duration::from_secs("),
                        "std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("),
 
@@ -1043,6 +1066,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
                        "core::convert::Infallible" => Some("\")"),
 
+                       "bitcoin::bech32::Error"|"bech32::Error" if !is_ref => Some(".into_rust()"),
+                       "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some(".into_rust()"),
+
+                       "core::num::ParseIntError" => Some("*/"),
+                       "core::str::Utf8Error" => Some("*/"),
+
                        "std::time::Duration"|"core::time::Duration" => Some(")"),
                        "std::time::SystemTime" => Some("))"),
 
@@ -1133,6 +1162,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
                        "core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
 
+                       "bitcoin::bech32::Error"|"bech32::Error"
+                               if !is_ref => Some("crate::c_types::Bech32Error::from_rust("),
+                       "bitcoin::secp256k1::Error"|"secp256k1::Error"
+                               if !is_ref => Some("crate::c_types::Secp256k1Error::from_rust("),
+
+                       "core::num::ParseIntError" => Some("crate::c_types::Error { _dummy: 0 } /*"),
+                       "core::str::Utf8Error" => Some("crate::c_types::Error { _dummy: 0 } /*"),
+
                        "bitcoin::bech32::u5"|"bech32::u5" => Some(""),
 
                        "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
@@ -1143,8 +1180,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                if is_ref => Some(""),
                        "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey"
                                if !is_ref => Some("crate::c_types::SecretKey::from_rust("),
-                       "bitcoin::secp256k1::Error"|"secp256k1::Error"
-                               if !is_ref => Some("crate::c_types::Secp256k1Error::from_rust("),
                        "bitcoin::blockdata::script::Script" if is_ref => Some("crate::c_types::u8slice::from_slice(&"),
                        "bitcoin::blockdata::script::Script" if !is_ref => Some(""),
                        "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" if is_ref => Some("crate::c_types::Transaction::from_bitcoin("),
@@ -1206,6 +1241,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
                        "core::convert::Infallible" => Some("\")"),
 
+                       "bitcoin::secp256k1::Error"|"bech32::Error"
+                               if !is_ref => Some(")"),
+                       "bitcoin::secp256k1::Error"|"secp256k1::Error"
+                               if !is_ref => Some(")"),
+
+                       "core::num::ParseIntError" => Some("*/"),
+                       "core::str::Utf8Error" => Some("*/"),
+
                        "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"),
 
                        "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
@@ -1216,8 +1259,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                if !is_ref => Some(")"),
                        "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey"
                                if is_ref => Some(".as_ref()"),
-                       "bitcoin::secp256k1::Error"|"secp256k1::Error"
-                               if !is_ref => Some(")"),
                        "bitcoin::blockdata::script::Script" if is_ref => Some("[..])"),
                        "bitcoin::blockdata::script::Script" if !is_ref => Some(".into_bytes().into()"),
                        "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(")"),
@@ -2844,7 +2885,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, true, false));
        }
        pub fn understood_c_path(&self, p: &syn::Path) -> bool {
-               if p.leading_colon.is_some() { return false; }
                self.write_c_path_intern(&mut std::io::sink(), p, None, false, false, false, false, true)
        }
        pub fn understood_c_type(&self, t: &syn::Type, generics: Option<&GenericTypes>) -> bool {