Merge pull request #94 from TheBlueMatt/main

Update for 0.0.112

Author: TheBlueMatt

.github/workflows/build.yml

@@ -37,7 +37,7 @@ jobs:
         run: |
           git clone https://github.com/rust-bitcoin/rust-lightning
           cd rust-lightning
-          git checkout 0.0.111-bindings
+          git checkout 0.0.112-bindings
       - name: Rebuild bindings without std, and check the sample app builds + links
         run: ./genbindings.sh ./rust-lightning false
       - name: Rebuild bindings, and check the sample app builds + links
@@ -88,7 +88,7 @@ jobs:
         run: |
           git clone https://github.com/rust-bitcoin/rust-lightning
           cd rust-lightning
-          git checkout 0.0.111-bindings
+          git checkout 0.0.112-bindings
       - name: Rebuild bindings using Apple clang, and check the sample app builds + links
         run: ./genbindings.sh ./rust-lightning true
       - name: Rebuild bindings using upstream clang, and check the sample app builds + links

c-bindings-gen/src/blocks.rs

@@ -747,7 +747,7 @@ pub fn write_method_call_params<W: std::io::Write>(w: &mut W, sig: &syn::Signatu
 
 /// Prints concrete generic parameters for a struct/trait/function, including the less-than and
 /// greater-than symbols, if any generic parameters are defined.
-pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, types: &TypeResolver, concrete_lifetimes: bool) {
+pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver, concrete_lifetimes: bool) {
 	let mut gen_types = GenericTypes::new(None);
 	assert!(gen_types.learn_generics(generics, types));
 	if generics.params.is_empty() { return; }
@@ -778,7 +778,15 @@ pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generi
 			syn::GenericParam::Type(type_param) => {
 				write!(w, "{}", if idx != 0 { ", " } else { "" }).unwrap();
 				let type_ident = &type_param.ident;
-				types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false);
+				if types.understood_c_type(&syn::parse_quote!(#type_ident), Some(&gen_types)) {
+					types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false);
+				} else {
+					if let syn::PathArguments::AngleBracketed(args) = generics_impld {
+						if let syn::GenericArgument::Type(ty) = &args.args[idx] {
+							types.write_c_type_in_generic_param(w, &ty, Some(&gen_types), false);
+						}
+					}
+				}
 			},
 			syn::GenericParam::Lifetime(lt) => {
 				if concrete_lifetimes {

c-bindings-gen/src/main.rs

@@ -205,10 +205,10 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 	}
 
 	/// Learn the generics in generics in the current context, given a TypeResolver.
-	pub fn learn_generics<'b, 'c>(&mut self, generics: &'a syn::Generics, types: &'b TypeResolver<'a, 'c>) -> bool {
+	pub fn learn_generics_with_impls<'b, 'c>(&mut self, generics: &'a syn::Generics, impld_generics: &'a syn::PathArguments, types: &'b TypeResolver<'a, 'c>) -> bool {
 		let mut new_typed_generics = HashMap::new();
 		// First learn simple generics...
-		for generic in generics.params.iter() {
+		for (idx, generic) in generics.params.iter().enumerate() {
 			match generic {
 				syn::GenericParam::Type(type_param) => {
 					let mut non_lifetimes_processed = false;
@@ -260,6 +260,15 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 					if let Some(default) = type_param.default.as_ref() {
 						assert!(type_param.bounds.is_empty());
 						self.default_generics.insert(&type_param.ident, (default.clone(), parse_quote!(&#default), parse_quote!(&mut #default)));
+					} else if type_param.bounds.is_empty() {
+						if let syn::PathArguments::AngleBracketed(args) = impld_generics {
+							match &args.args[idx] {
+								syn::GenericArgument::Type(ty) => {
+									self.default_generics.insert(&type_param.ident, (ty.clone(), parse_quote!(&#ty), parse_quote!(&mut #ty)));
+								}
+								_ => unimplemented!(),
+							}
+						}
 					}
 				},
 				_ => {},
@@ -270,6 +279,7 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 			for pred in wh.predicates.iter() {
 				if let syn::WherePredicate::Type(t) = pred {
 					if let syn::Type::Path(p) = &t.bounded_ty {
+						if first_seg_self(&t.bounded_ty).is_some() && p.path.segments.len() == 1 { continue; }
 						if p.qself.is_some() { return false; }
 						if p.path.leading_colon.is_some() { return false; }
 						let mut p_iter = p.path.segments.iter();
@@ -315,6 +325,11 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 		true
 	}
 
+	/// Learn the generics in generics in the current context, given a TypeResolver.
+	pub fn learn_generics<'b, 'c>(&mut self, generics: &'a syn::Generics, types: &'b TypeResolver<'a, 'c>) -> bool {
+		self.learn_generics_with_impls(generics, &syn::PathArguments::None, types)
+	}
+
 	/// Learn the associated types from the trait in the current context.
 	pub fn learn_associated_types<'b, 'c>(&mut self, t: &'a syn::ItemTrait, types: &'b TypeResolver<'a, 'c>) {
 		for item in t.items.iter() {
@@ -635,6 +650,8 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
 				Some(format!("{}::{}{}", self.module_path, first_seg.ident, remaining))
 			} else if first_seg_is_stdlib(&first_seg_str) || self.dependencies.contains(&first_seg.ident) {
 				Some(first_seg_str + &remaining)
+			} else if first_seg_str == "crate" {
+				Some(self.crate_name.to_owned() + &remaining)
 			} else { None }
 		}
 	}
@@ -915,7 +932,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 			"std::time::Duration"|"core::time::Duration" => Some("u64"),
 			"std::time::SystemTime" => Some("u64"),
-			"std::io::Error"|"lightning::io::Error" => Some("crate::c_types::IOError"),
+			"std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some("crate::c_types::IOError"),
 			"core::fmt::Arguments" if is_ref => Some("crate::c_types::Str"),
 
 			"core::convert::Infallible" => Some("crate::c_types::NotConstructable"),
@@ -1000,7 +1017,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 			"str" if is_ref => Some(""),
 			"alloc::string::String"|"String" => Some(""),
-			"std::io::Error"|"lightning::io::Error" => Some(""),
+			"std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some(""),
 			// Note that we'll panic for String if is_ref, as we only have non-owned memory, we
 			// cannot create a &String.
 
@@ -1091,6 +1108,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"str" if is_ref => Some(".into_str()"),
 			"alloc::string::String"|"String" => Some(".into_string()"),
 			"std::io::Error"|"lightning::io::Error" => Some(".to_rust()"),
+			"lightning::io::ErrorKind" => Some(".to_rust_kind()"),
 
 			"core::convert::Infallible" => Some("\")"),
 
@@ -1187,6 +1205,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"std::time::Duration"|"core::time::Duration" => Some(""),
 			"std::time::SystemTime" => Some(""),
 			"std::io::Error"|"lightning::io::Error" => Some("crate::c_types::IOError::from_rust("),
+			"lightning::io::ErrorKind" => Some("crate::c_types::IOError::from_rust_kind("),
 			"core::fmt::Arguments" => Some("alloc::format!(\"{}\", "),
 
 			"core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
@@ -1266,7 +1285,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 			"std::time::Duration"|"core::time::Duration" => Some(".as_secs()"),
 			"std::time::SystemTime" => Some(".duration_since(::std::time::SystemTime::UNIX_EPOCH).expect(\"Times must be post-1970\").as_secs()"),
-			"std::io::Error"|"lightning::io::Error" => Some(")"),
+			"std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some(")"),
 			"core::fmt::Arguments" => Some(").into()"),
 
 			"core::convert::Infallible" => Some("\")"),

c-bindings-gen/src/types.rs

@@ -272,7 +272,7 @@ while read LINE; do
 				echo "Unable to find method declaration for $LINE"
 				exit 1
 			fi
-			RETVAL="$(echo "$METHOD" | sed 's/[ ]*\([A-Za-z0-9 _]*\)(\*\(.*\)).*/\1/' | sed 's/^struct LDK/LDK::/g' | tr -d ' ')"
+			RETVAL="$(echo "$METHOD" | sed 's/[ ]*\([A-Za-z0-9 _]*\)(\*\(.*\)).*/\1/' | sed -E 's/^(struct|enum) LDK/LDK::/g' | tr -d ' ')"
 			[ "$RETVAL" = "LDK::SecretKey" ] && RETVAL="LDKSecretKey"
 			[ "$RETVAL" = "LDK::PublicKey" ] && RETVAL="LDKPublicKey"
 			[ "$RETVAL" = "LDK::ThirtyTwoBytes" ] && RETVAL="LDKThirtyTwoBytes"

genbindings.sh

@@ -22,11 +22,11 @@ std = ["bitcoin/std", "lightning/std", "lightning-invoice/std"]
 bitcoin = { version = "0.29", default-features = false }
 secp256k1 = { version = "0.24", features = ["global-context", "recovery"] }
 # Note that the following line is matched by genbindings to update the path
-lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.111-bindings", default-features = false }
-lightning-persister = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.111-bindings", default-features = false }
-lightning-invoice = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.111-bindings", default-features = false }
-lightning-background-processor = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.111-bindings", default-features = false }
-lightning-rapid-gossip-sync = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.111-bindings", default-features = false }
+lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.112-bindings", default-features = false }
+lightning-persister = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.112-bindings", default-features = false }
+lightning-invoice = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.112-bindings", default-features = false }
+lightning-background-processor = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.112-bindings", default-features = false }
+lightning-rapid-gossip-sync = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "0.0.112-bindings", default-features = false }
 
 core2 = { version = "0.3.0", optional = true, default-features = false }
 

lightning-c-bindings/Cargo.toml

@@ -25,11 +25,11 @@ void broadcast_tx(const void *this_arg, LDKTransaction tx) {
 	Transaction_free(tx);
 }
 
-LDKCResult_NoneChannelMonitorUpdateErrZ add_channel_monitor(const void *this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
-	return CResult_NoneChannelMonitorUpdateErrZ_ok();
+LDKChannelMonitorUpdateStatus add_channel_monitor(const void *this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
+	return ChannelMonitorUpdateStatus_completed();
 }
-LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_monitor(const void *this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate monitor) {
-	return CResult_NoneChannelMonitorUpdateErrZ_ok();
+LDKChannelMonitorUpdateStatus update_channel_monitor(const void *this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate monitor) {
+	return ChannelMonitorUpdateStatus_completed();
 }
 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ monitors_pending_monitor_events(const void *this_arg) {
 	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ empty_htlc_vec = {