X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=e45fdca095ddb5552cb72f95d81bc631af2b0ff1;hb=4f282d4cdae9b2e79e4fd604b629517898f02262;hp=8cc7d1eaa501f3bfcf16d80ae15a655999a631ab;hpb=85846b4b2d0e7378ce2d4605f6356925f89e736b;p=ldk-c-bindings diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 8cc7d1e..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; }, @@ -474,9 +479,12 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr let crate_name_ident = format_ident!("{}", crate_name); path.push(parse_quote!(#crate_name_ident)); } else if partial_path == "" && !dependencies.contains(&$ident) { - new_path = format!("{}::{}{}", crate_name, $ident, $path_suffix); - let crate_name_ident = format_ident!("{}", crate_name); - path.push(parse_quote!(#crate_name_ident)); + new_path = format!("{}::{}{}", module_path, $ident, $path_suffix); + for module in module_path.split("::") { + path.push(syn::PathSegment { ident: syn::Ident::new(module, Span::call_site()), arguments: syn::PathArguments::None }); + } + let ident_str = format_ident!("{}", $ident); + path.push(parse_quote!(#ident_str)); } else if format!("{}", $ident) == "self" { let mut path_iter = partial_path.rsplitn(2, "::"); path_iter.next().unwrap(); @@ -814,6 +822,7 @@ fn initial_clonable_types() -> HashSet { res.insert("crate::c_types::TxOut".to_owned()); res.insert("crate::c_types::Signature".to_owned()); res.insert("crate::c_types::RecoverableSignature".to_owned()); + res.insert("crate::c_types::BigEndianScalar".to_owned()); res.insert("crate::c_types::Bech32Error".to_owned()); res.insert("crate::c_types::Secp256k1Error".to_owned()); res.insert("crate::c_types::IOError".to_owned()); @@ -1451,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 @@ -1531,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, } @@ -1624,7 +1627,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap(); return Some(("if ", vec![ (format!(".is_none() {{ {}::None }} else {{ {}::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */", inner_name, inner_name), - format!("{}.clone().unwrap()", var_access)) + format!("(*{}.as_ref().unwrap()).clone()", var_access)) ], ") }", ContainerPrefixLocation::PerConv)); } } else { @@ -1992,19 +1995,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } } - fn is_real_type_array(&self, resolved_type: &str) -> Option { - 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(&self, generics: Option<&GenericTypes>, w: &mut W, t: &syn::Type) -> EmptyValExpectedTy { @@ -2014,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 @@ -2806,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 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 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();