X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=e45fdca095ddb5552cb72f95d81bc631af2b0ff1;hb=4f282d4cdae9b2e79e4fd604b629517898f02262;hp=398d0241c61d3b10d524e37a602a5c0a3fc3e2aa;hpb=4b3fb779db8866b0f557d9daf997d102a3330b8e;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 398d024..e45fdca 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -215,7 +215,7 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 					'bound_loop: for bound in type_param.bounds.iter() {
 						if let syn::TypeParamBound::Trait(trait_bound) = bound {
 							if let Some(ident) = single_ident_generic_path_to_ident(&trait_bound.path) {
-								match &format!("{}", ident) as &str { "Send" => continue, "Sync" => continue, _ => {} }
+								match &format!("{}", ident) as &str { "Send" => continue, "Sync" => continue, "Sized" => continue, _ => {} }
 							}
 							if path_matches_nongeneric(&trait_bound.path, &["core", "clone", "Clone"]) { continue; }
 
@@ -352,7 +352,12 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 									}
 								} else { unimplemented!(); }
 								for bound in bounds_iter {
-									if let syn::TypeParamBound::Trait(_) = bound { unimplemented!(); }
+									if let syn::TypeParamBound::Trait(t) = bound {
+										// We only allow for `?Sized` here.
+										if let syn::TraitBoundModifier::Maybe(_) = t.modifier {} else { panic!(); }
+										assert_eq!(t.path.segments.len(), 1);
+										assert_eq!(format!("{}", t.path.segments[0].ident), "Sized");
+									}
 								}
 								break;
 							},
@@ -1455,7 +1460,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 	fn empty_val_check_suffix_from_path(&self, full_path: &str) -> Option<&str> {
 		match full_path {
-			"lightning::ln::PaymentSecret" => Some(".data == [0; 32]"),
 			"secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => Some(".is_null()"),
 			"bitcoin::secp256k1::ecdsa::Signature" => Some(".is_null()"),
 			_ => None
@@ -1535,11 +1539,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 						// clear for users. Thus, we default to false but override for a few
 						// types which had mappings defined when we were avoiding the `Option_`s.
 						match &resolved as &str {
-							"lightning::ln::PaymentSecret" => true,
-							"lightning::ln::PaymentHash" => true,
-							"lightning::ln::PaymentPreimage" => true,
-							"lightning::ln::channelmanager::PaymentId" => true,
-							"bitcoin::hash_types::BlockHash"|"bitcoin::BlockHash" => true,
 							"secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => true,
 							_ => false,
 						}
@@ -1996,19 +1995,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		}
 	}
 
-	fn is_real_type_array(&self, resolved_type: &str) -> Option<syn::Type> {
-		if let Some(real_ty) = self.c_type_from_path(&resolved_type, true, false) {
-			if real_ty.ends_with("]") && real_ty.starts_with("*const [u8; ") {
-				let mut split = real_ty.split("; ");
-				split.next().unwrap();
-				let tail_str = split.next().unwrap();
-				assert!(split.next().is_none());
-				let len = usize::from_str_radix(&tail_str[..tail_str.len() - 1], 10).unwrap();
-				Some(parse_quote!([u8; #len]))
-			} else { None }
-		} else { None }
-	}
-
 	/// Prints a suffix to determine if a variable is empty (ie was set by write_empty_rust_val).
 	/// See EmptyValExpectedTy for information on return types.
 	fn write_empty_rust_val_check_suffix<W: std::io::Write>(&self, generics: Option<&GenericTypes>, w: &mut W, t: &syn::Type) -> EmptyValExpectedTy {
@@ -2018,9 +2004,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			},
 			syn::Type::Path(p) => {
 				let resolved = self.resolve_path(&p.path, generics);
-				if let Some(arr_ty) = self.is_real_type_array(&resolved) {
-					return self.write_empty_rust_val_check_suffix(generics, w, &arr_ty);
-				}
 				if self.crate_types.opaques.get(&resolved).is_some() {
 					write!(w, ".inner.is_null()").unwrap();
 					EmptyValExpectedTy::NonPointer
@@ -2810,12 +2793,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 								if self.c_type_has_inner_from_path(&subtype) {
 									if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref, false, true) { return false; }
 								} else {
-									if let Some(arr_ty) = self.is_real_type_array(&subtype) {
-										if !self.write_c_type_intern(w, &arr_ty, generics, false, true, false, false, true) { return false; }
-									} else {
-										// Option<T> needs to be converted to a *mut T, ie mut ptr-for-ref
-										if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true, false, true) { return false; }
-									}
+									// Option<T> needs to be converted to a *mut T, ie mut ptr-for-ref
+									if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true, false, true) { return false; }
 								}
 							} else {
 								write!(w, "{}", $p_arg.path.segments.last().unwrap().ident).unwrap();