X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=5fd874d3308ce04e362729d97dd13729115459e4;hb=0ef1156801165f50037165350be565209b805d89;hp=8f5e66735d5df40784fef02306ed95d2ec27cb14;hpb=c98ebb54cc7f57f8c4c31d01ec69c81b172e49b1;p=ldk-c-bindings diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 8f5e667..5fd874d 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -147,7 +147,7 @@ pub fn export_status(attrs: &[syn::Attribute]) -> ExportStatus { } pub fn assert_simple_bound(bound: &syn::TraitBound) { - if bound.paren_token.is_some() || bound.lifetimes.is_some() { unimplemented!(); } + if bound.paren_token.is_some() { unimplemented!(); } if let syn::TraitBoundModifier::Maybe(_) = bound.modifier { unimplemented!(); } } @@ -705,6 +705,7 @@ impl FullLibraryAST { let modname = if module != "" { module.clone() + "::" + &modident } else { + self.dependencies.insert(m.ident); modident.clone() }; self.load_module(modname, m.attrs, m.content.unwrap().1); @@ -1339,20 +1340,33 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "crate::c_types" } + /// This should just be a closure, but doing so gets an error like + /// error: reached the recursion limit while instantiating `types::TypeResolver::is_transpar...c/types.rs:1358:104: 1358:110]>>` + /// which implies the concrete function instantiation of `is_transparent_container` ends up + /// being recursive. + fn deref_type<'one, 'b: 'one> (obj: &'one &'b syn::Type) -> &'b syn::Type { *obj } + /// Returns true if the path containing the given args is a "transparent" container, ie an /// Option or a container which does not require a generated continer class. fn is_transparent_container<'i, I: Iterator>(&self, full_path: &str, _is_ref: bool, mut args: I, generics: Option<&GenericTypes>) -> bool { if full_path == "Option" { let inner = args.next().unwrap(); assert!(args.next().is_none()); - match inner { - syn::Type::Reference(_) => true, + match generics.resolve_type(inner) { + syn::Type::Reference(r) => { + let elem = &*r.elem; + match elem { + syn::Type::Path(_) => + self.is_transparent_container(full_path, true, [elem].iter().map(Self::deref_type), generics), + _ => true, + } + }, syn::Type::Array(a) => { if let syn::Expr::Lit(l) = &a.len { if let syn::Lit::Int(i) = &l.lit { if i.base10_digits().parse::().unwrap() >= 32 { let mut buf = Vec::new(); - self.write_rust_type(&mut buf, generics, &a.elem); + self.write_rust_type(&mut buf, generics, &a.elem, false); let ty = String::from_utf8(buf).unwrap(); ty == "u8" } else { @@ -1367,8 +1381,20 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if let Some(resolved) = self.maybe_resolve_path(&p.path, generics) { if self.c_type_has_inner_from_path(&resolved) { return true; } if self.is_primitive(&resolved) { return false; } - if self.c_type_from_path(&resolved, false, false).is_some() { true } else { false } - } else { true } + // We want to move to using `Option_` mappings where possible rather than + // manual mappings, as it makes downstream bindings simpler and is more + // 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" => true, + "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => true, + _ => false, + } + } else { unimplemented!(); } }, syn::Type::Tuple(_) => false, _ => unimplemented!(), @@ -1442,7 +1468,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { (".is_none() { core::ptr::null_mut() } else { ".to_owned(), format!("({}.unwrap())", var_access)) ], " }", ContainerPrefixLocation::OutsideConv)); } - } else if self.is_primitive(&inner_path) || self.c_type_from_path(&inner_path, false, false).is_none() { + } else if !self.is_transparent_container("Option", is_ref, [single_contained.unwrap()].iter().map(|a| *a), generics) { if self.is_primitive(&inner_path) || (!is_contained_ref && !is_ref) || only_contained_has_inner { let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap(); return Some(("if ", vec![ @@ -1463,12 +1489,18 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } if let Some(t) = single_contained { if let syn::Type::Tuple(syn::TypeTuple { elems, .. }) = t { - assert!(elems.is_empty()); 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 /*", - inner_name, inner_name), format!("")) - ], " */}", ContainerPrefixLocation::PerConv)); + if elems.is_empty() { + return Some(("if ", vec![ + (format!(".is_none() {{ {}::None }} else {{ {}::Some /* ", + inner_name, inner_name), format!("")) + ], " */ }", ContainerPrefixLocation::PerConv)); + } else { + return Some(("if ", vec![ + (format!(".is_none() {{ {}::None }} else {{ {}::Some(", + inner_name, inner_name), format!("({}.unwrap())", var_access)) + ], ") }", ContainerPrefixLocation::PerConv)); + } } if let syn::Type::Reference(syn::TypeReference { elem, .. }) = t { if let syn::Type::Slice(_) = &**elem { @@ -1652,7 +1684,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } } - fn write_rust_path(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, path: &syn::Path) { + fn write_rust_path(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, path: &syn::Path, with_ref_lifetime: bool, generated_crate_ref: bool) { if let Some(resolved) = self.maybe_resolve_path(&path, generics_resolver) { if self.is_primitive(&resolved) { write!(w, "{}", path.get_ident().unwrap()).unwrap(); @@ -1661,16 +1693,16 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // checking for "bitcoin" explicitly. if resolved.starts_with("bitcoin::") || Self::in_rust_prelude(&resolved) { write!(w, "{}", resolved).unwrap(); - // 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) { + } else if !generated_crate_ref { + // If we're printing a generic argument, it needs to reference the crate, otherwise + // the original crate. write!(w, "{}", self.real_rust_type_mapping(&resolved)).unwrap(); } else { write!(w, "crate::{}", resolved).unwrap(); } } if let syn::PathArguments::AngleBracketed(args) = &path.segments.iter().last().unwrap().arguments { - self.write_rust_generic_arg(w, generics_resolver, args.args.iter()); + self.write_rust_generic_arg(w, generics_resolver, args.args.iter(), with_ref_lifetime); } } else { if path.leading_colon.is_some() { @@ -1680,7 +1712,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if idx != 0 { write!(w, "::").unwrap(); } write!(w, "{}", seg.ident).unwrap(); if let syn::PathArguments::AngleBracketed(args) = &seg.arguments { - self.write_rust_generic_arg(w, generics_resolver, args.args.iter()); + self.write_rust_generic_arg(w, generics_resolver, args.args.iter(), with_ref_lifetime); } } } @@ -1700,7 +1732,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { match bound { syn::TypeParamBound::Trait(tb) => { if tb.paren_token.is_some() || tb.lifetimes.is_some() { unimplemented!(); } - self.write_rust_path(w, generics_resolver, &tb.path); + self.write_rust_path(w, generics_resolver, &tb.path, false, false); }, _ => unimplemented!(), } @@ -1713,38 +1745,46 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if had_params { write!(w, ">").unwrap(); } } - pub fn write_rust_generic_arg<'b, W: std::io::Write>(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, generics: impl Iterator) { + pub fn write_rust_generic_arg<'b, W: std::io::Write>(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, generics: impl Iterator, with_ref_lifetime: bool) { write!(w, "<").unwrap(); for (idx, arg) in generics.enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } match arg { - syn::GenericArgument::Type(t) => self.write_rust_type(w, generics_resolver, t), + syn::GenericArgument::Type(t) => self.write_rust_type(w, generics_resolver, t, with_ref_lifetime), _ => unimplemented!(), } } write!(w, ">").unwrap(); } - pub fn write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type) { - match generics.resolve_type(t) { + fn do_write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type, with_ref_lifetime: bool, force_crate_ref: bool) { + let real_ty = generics.resolve_type(t); + let mut generate_crate_ref = force_crate_ref || t != real_ty; + match real_ty { syn::Type::Path(p) => { if p.qself.is_some() { unimplemented!(); } - self.write_rust_path(w, generics, &p.path); + if let Some(resolved_ty) = self.maybe_resolve_path(&p.path, generics) { + generate_crate_ref |= self.maybe_resolve_path(&p.path, None).as_ref() != Some(&resolved_ty); + if self.crate_types.traits.get(&resolved_ty).is_none() { generate_crate_ref = false; } + } + self.write_rust_path(w, generics, &p.path, with_ref_lifetime, generate_crate_ref); }, syn::Type::Reference(r) => { write!(w, "&").unwrap(); if let Some(lft) = &r.lifetime { write!(w, "'{} ", lft.ident).unwrap(); + } else if with_ref_lifetime { + write!(w, "'static ").unwrap(); } if r.mutability.is_some() { write!(w, "mut ").unwrap(); } - self.write_rust_type(w, generics, &*r.elem); + self.do_write_rust_type(w, generics, &*r.elem, with_ref_lifetime, generate_crate_ref); }, syn::Type::Array(a) => { write!(w, "[").unwrap(); - self.write_rust_type(w, generics, &a.elem); + self.do_write_rust_type(w, generics, &a.elem, with_ref_lifetime, generate_crate_ref); if let syn::Expr::Lit(l) = &a.len { if let syn::Lit::Int(i) = &l.lit { write!(w, "; {}]", i).unwrap(); @@ -1753,20 +1793,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } syn::Type::Slice(s) => { write!(w, "[").unwrap(); - self.write_rust_type(w, generics, &s.elem); + self.do_write_rust_type(w, generics, &s.elem, with_ref_lifetime, generate_crate_ref); write!(w, "]").unwrap(); }, syn::Type::Tuple(s) => { write!(w, "(").unwrap(); for (idx, t) in s.elems.iter().enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } - self.write_rust_type(w, generics, &t); + self.do_write_rust_type(w, generics, &t, with_ref_lifetime, generate_crate_ref); } write!(w, ")").unwrap(); }, _ => unimplemented!(), } } + pub fn write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type, with_ref_lifetime: bool) { + self.do_write_rust_type(w, generics, t, with_ref_lifetime, false); + } + /// Prints a constructor for something which is "uninitialized" (but obviously not actually /// unint'd memory). @@ -2013,6 +2057,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { write!(w, "{}", sliceconv(false, None)).unwrap(); } } + } else if let syn::Type::Array(_) = &*s.elem { + write!(w, "{}", sliceconv(false, Some(".map(|a| *a)"))).unwrap(); } else { unimplemented!(); } }, syn::Type::Tuple(t) => { @@ -2176,7 +2222,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // For slices (and Options), we refuse to directly map them as is_ref when they // aren't opaque types containing an inner pointer. This is due to the fact that, // in both cases, the actual higher-level type is non-is_ref. - let ty_has_inner = if $args_len == 1 { + let (ty_has_inner, ty_is_trait) = if $args_len == 1 { let ty = $args_iter().next().unwrap(); if $container_type == "Slice" && to_c { // "To C ptr_for_ref" means "return the regular object with is_owned @@ -2186,12 +2232,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } if let syn::Type::Reference(t) = ty { if let syn::Type::Path(p) = &*t.elem { - self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)) - } else { false } + let resolved = self.resolve_path(&p.path, generics); + (self.c_type_has_inner_from_path(&resolved), self.crate_types.traits.get(&resolved).is_some()) + } else { (false, false) } } else if let syn::Type::Path(p) = ty { - self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)) - } else { false } - } else { true }; + let resolved = self.resolve_path(&p.path, generics); + (self.c_type_has_inner_from_path(&resolved), self.crate_types.traits.get(&resolved).is_some()) + } else { (false, false) } + } else { (true, false) }; // Options get a bunch of special handling, since in general we map Option<>al // types into the same C type as non-Option-wrapped types. This ends up being @@ -2215,7 +2263,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // If the inner element contains an inner pointer, we will just use that, // avoiding the need to map elements to references. Otherwise we'll need to // do an extra mapping step. - needs_ref_map = !only_contained_has_inner && $container_type == "Option"; + needs_ref_map = !only_contained_has_inner && !ty_is_trait && $container_type == "Option"; } else { only_contained_type = Some(arg); only_contained_type_nonref = Some(arg); @@ -2363,6 +2411,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { ptr_for_ref = true; convert_container!("Slice", 1, || ty.iter()); unimplemented!("convert_container should return true as container_lookup should succeed for slices"); + } else if let syn::Type::Array(_) = &*s.elem { + is_ref = false; + ptr_for_ref = true; + let arr_elem = [(*s.elem).clone()]; + convert_container!("Slice", 1, || arr_elem.iter()); + unimplemented!("convert_container should return true as container_lookup should succeed for slices"); } else { unimplemented!() } }, syn::Type::Tuple(t) => { @@ -2463,10 +2517,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // ****************************************************** fn write_template_generics<'b, W: std::io::Write>(&self, w: &mut W, args: &mut dyn Iterator, generics: Option<&GenericTypes>, is_ref: bool) -> bool { - for (idx, t) in args.enumerate() { + for (idx, orig_t) in args.enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } + let t = generics.resolve_type(orig_t); if let syn::Type::Reference(r_arg) = t { assert!(!is_ref); // We don't currently support outer reference types for non-primitive inners @@ -2478,6 +2533,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if let syn::Type::Path(p_arg) = &*r_arg.elem { let resolved = self.resolve_path(&p_arg.path, generics); assert!(self.crate_types.opaques.get(&resolved).is_some() || + self.crate_types.traits.get(&resolved).is_some() || self.c_type_from_path(&resolved, true, true).is_some(), "Template generics should be opaque or have a predefined mapping"); } else { unimplemented!(); } } else if let syn::Type::Path(p_arg) = t { @@ -2759,7 +2815,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // lifetime, of which the only real available choice is `static`, obviously. write!(w, "&'static {}", crate_pfx).unwrap(); if !c_ty { - self.write_rust_path(w, generics, path); + self.write_rust_path(w, generics, path, with_ref_lifetime, false); } else { // We shouldn't be mapping references in types, so panic here unimplemented!(); @@ -2871,6 +2927,22 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { let mut segments = syn::punctuated::Punctuated::new(); segments.push(parse_quote!(Vec<#args>)); self.write_c_type_intern(w, &syn::Type::Path(syn::TypePath { qself: None, path: syn::Path { leading_colon: None, segments } }), generics, false, is_mut, ptr_for_ref, with_ref_lifetime, c_ty) + } else if let syn::Type::Array(a) = &*s.elem { + if let syn::Expr::Lit(l) = &a.len { + if let syn::Lit::Int(i) = &l.lit { + let mut buf = Vec::new(); + self.write_rust_type(&mut buf, generics, &*a.elem, false); + let arr_ty = String::from_utf8(buf).unwrap(); + + let arr_str = format!("[{}; {}]", arr_ty, i.base10_digits()); + let ty = self.c_type_from_path(&arr_str, false, ptr_for_ref).unwrap() + .rsplitn(2, "::").next().unwrap(); + + let mangled_container = format!("CVec_{}Z", ty); + write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap(); + self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false) + } else { false } + } else { false } } else { false } }, syn::Type::Tuple(t) => {