X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=b4b46a833a38e65bde039fabc348c68619a0fe44;hb=bd76083ef39691612107fca226bad84498fc3396;hp=cfa5b5f15fc0d2eacddb74cc188a4ae69bb2c908;hpb=7613eb0c40d726769bfc2b43e84421017858c532;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index cfa5b5f..b4b46a8 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -889,6 +889,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"std::time::SystemTime" => Some("u64"),
 			"std::io::Error" => Some("crate::c_types::IOError"),
 
+			"core::convert::Infallible" => Some("crate::c_types::NotConstructable"),
+
 			"bech32::u5" => Some("crate::c_types::u5"),
 			"core::num::NonZeroU8" => Some("u8"),
 
@@ -931,6 +933,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Override the default since Records contain an fmt with a lifetime:
 			"lightning::util::logger::Record" => Some("*const std::os::raw::c_char"),
 
+			"lightning::io::Read" => Some("crate::c_types::u8slice"),
+
 			_ => None,
 		}
 	}
@@ -965,6 +969,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Note that we'll panic for String if is_ref, as we only have non-owned memory, we
 			// cannot create a &String.
 
+			"core::convert::Infallible" => Some("panic!(\"You must never construct a NotConstructable! : "),
+
 			"std::time::Duration"|"core::time::Duration" => Some("std::time::Duration::from_secs("),
 			"std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("),
 
@@ -1014,6 +1020,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// List of traits we map (possibly during processing of other files):
 			"crate::util::logger::Logger" => Some(""),
 
+			"lightning::io::Read" => Some("&mut "),
+
 			_ => None,
 		}.map(|s| s.to_owned())
 	}
@@ -1041,6 +1049,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"alloc::string::String"|"String" => Some(".into_string()"),
 			"std::io::Error" if !is_ref => Some(".to_rust()"),
 
+			"core::convert::Infallible" => Some("\")"),
+
 			"std::time::Duration"|"core::time::Duration" => Some(")"),
 			"std::time::SystemTime" => Some("))"),
 
@@ -1081,6 +1091,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// List of traits we map (possibly during processing of other files):
 			"crate::util::logger::Logger" => Some(""),
 
+			"lightning::io::Read" => Some(".to_reader()"),
+
 			_ => None,
 		}.map(|s| s.to_owned())
 	}
@@ -1130,6 +1142,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"std::time::SystemTime" => Some(""),
 			"std::io::Error" if !is_ref => Some("crate::c_types::IOError::from_rust("),
 
+			"core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
+
 			"bech32::u5" => Some(""),
 
 			"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
@@ -1169,6 +1183,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Override the default since Records contain an fmt with a lifetime:
 			"lightning::util::logger::Record" => Some("local_"),
 
+			"lightning::io::Read" => Some("crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec("),
+
 			_ => None,
 		}.map(|s| s.to_owned())
 	}
@@ -1200,6 +1216,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			"std::time::SystemTime" => Some(".duration_since(::std::time::SystemTime::UNIX_EPOCH).expect(\"Times must be post-1970\").as_secs()"),
 			"std::io::Error" if !is_ref => Some(")"),
 
+			"core::convert::Infallible" => Some("\")"),
+
 			"bech32::u5" => Some(".into()"),
 
 			"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
@@ -1238,6 +1256,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			// Override the default since Records contain an fmt with a lifetime:
 			"lightning::util::logger::Record" => Some(".as_ptr()"),
 
+			"lightning::io::Read" => Some("))"),
+
 			_ => None,
 		}.map(|s| s.to_owned())
 	}
@@ -1251,6 +1271,18 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		}
 	}
 
+	/// When printing a reference to the source crate's rust type, if we need to map it to a
+	/// different "real" type, it can be done so here.
+	/// This is useful to work around limitations in the binding type resolver, where we reference
+	/// a non-public `use` alias.
+	/// TODO: We should never need to use this!
+	fn real_rust_type_mapping<'equiv>(&self, thing: &'equiv str) -> &'equiv str {
+		match thing {
+			"lightning::io::Read" => "std::io::Read",
+			_ => thing,
+		}
+	}
+
 	// ****************************
 	// *** Container Processing ***
 	// ****************************
@@ -1547,7 +1579,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 				// If we're printing a generic argument, it needs to reference the crate, otherwise
 				// the original crate:
 				} else if self.maybe_resolve_path(&path, None).as_ref() == Some(&resolved) {
-					write!(w, "{}", resolved).unwrap();
+					write!(w, "{}", self.real_rust_type_mapping(&resolved)).unwrap();
 				} else {
 					write!(w, "crate::{}", resolved).unwrap();
 				}