use types::*;
use blocks::*;
-const DEFAULT_IMPORTS: &'static str = "\nuse std::str::FromStr;\nuse std::ffi::c_void;\nuse bitcoin::hashes::Hash;\nuse crate::c_types::*;\n";
+const DEFAULT_IMPORTS: &'static str = "
+use alloc::str::FromStr;
+use core::ffi::c_void;
+use core::convert::Infallible;
+use bitcoin::hashes::Hash;
+use crate::c_types::*;
+#[cfg(feature=\"no-std\")]
+use alloc::{vec::Vec, boxed::Box};
+";
// *************************************
// *** Manually-expanded conversions ***
writeln!(w, "}}").unwrap();
}
},
- "lightning::util::ser::Readable"|"lightning::util::ser::ReadableArgs" => {
+ "lightning::util::ser::Readable"|"lightning::util::ser::ReadableArgs"|"lightning::util::ser::MaybeReadable" => {
// Create the Result<Object, DecodeError> syn::Type
- let res_ty: syn::Type = parse_quote!(Result<#for_ty, ::ln::msgs::DecodeError>);
+ let mut res_ty: syn::Type = parse_quote!(Result<#for_ty, ::ln::msgs::DecodeError>);
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Read a {} from a byte array, created by {}_write", for_obj, for_obj).unwrap();
types.write_from_c_conversion_suffix(&mut arg_conv, &args_ty, Some(generics));
} else { unreachable!(); }
} else { unreachable!(); }
+ } else if t == "lightning::util::ser::MaybeReadable" {
+ res_ty = parse_quote!(Result<Option<#for_ty>, ::ln::msgs::DecodeError>);
}
write!(w, ") -> ").unwrap();
types.write_c_type(w, &res_ty, Some(generics), false);
if t == "lightning::util::ser::ReadableArgs" {
w.write(&arg_conv).unwrap();
- write!(w, ";\n\tlet res: ").unwrap();
- // At least in one case we need type annotations here, so provide them.
- types.write_rust_type(w, Some(generics), &res_ty);
+ write!(w, ";\n").unwrap();
+ }
+
+ write!(w, "\tlet res: ").unwrap();
+ // At least in one case we need type annotations here, so provide them.
+ types.write_rust_type(w, Some(generics), &res_ty);
+
+ if t == "lightning::util::ser::ReadableArgs" {
writeln!(w, " = crate::c_types::deserialize_obj_arg(ser, arg_conv);").unwrap();
+ } else if t == "lightning::util::ser::MaybeReadable" {
+ writeln!(w, " = crate::c_types::maybe_deserialize_obj(ser);").unwrap();
} else {
- writeln!(w, "\tlet res = crate::c_types::deserialize_obj(ser);").unwrap();
+ writeln!(w, " = crate::c_types::deserialize_obj(ser);").unwrap();
}
write!(w, "\t").unwrap();
if types.write_to_c_conversion_new_var(w, &format_ident!("res"), &res_ty, Some(generics), false) {
match trait_path {
"lightning::util::ser::Writeable" => {
writeln!(w, "impl {} for {} {{", trait_path, for_obj).unwrap();
- writeln!(w, "\tfn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {{").unwrap();
+ writeln!(w, "\tfn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), crate::c_types::io::Error> {{").unwrap();
writeln!(w, "\t\tlet vec = (self.write)(self.this_arg);").unwrap();
writeln!(w, "\t\tw.write_all(vec.as_slice())").unwrap();
writeln!(w, "\t}}\n}}").unwrap();
}
}
+/// Returns true if an instance of the given type must never exist
+fn is_type_unconstructable(path: &str) -> bool {
+ path == "core::convert::Infallible" || path == "crate::c_types::NotConstructable"
+}
+
// *******************************
// *** Per-Type Printing Logic ***
// *******************************
&syn::TraitItem::Type(ref t) => {
if t.default.is_some() || t.generics.lt_token.is_some() { unimplemented!(); }
let mut bounds_iter = t.bounds.iter();
- match bounds_iter.next().unwrap() {
- syn::TypeParamBound::Trait(tr) => {
- writeln!(w, "\ttype {} = crate::{};", t.ident, $type_resolver.resolve_path(&tr.path, Some(&gen_types))).unwrap();
- },
- _ => unimplemented!(),
+ loop {
+ match bounds_iter.next().unwrap() {
+ syn::TypeParamBound::Trait(tr) => {
+ writeln!(w, "\ttype {} = crate::{};", t.ident, $type_resolver.resolve_path(&tr.path, Some(&gen_types))).unwrap();
+ for bound in bounds_iter {
+ if let syn::TypeParamBound::Trait(_) = bound { unimplemented!(); }
+ }
+ break;
+ },
+ syn::TypeParamBound::Lifetime(_) => {},
+ }
}
- if bounds_iter.next().is_some() { unimplemented!(); }
},
_ => unimplemented!(),
}
// Implement supertraits for the C-mapped struct.
walk_supertraits!(t, Some(&types), (
("std::cmp::Eq", _)|("core::cmp::Eq", _) => {
- writeln!(w, "impl std::cmp::Eq for {} {{}}", trait_name).unwrap();
- writeln!(w, "impl std::cmp::PartialEq for {} {{", trait_name).unwrap();
+ writeln!(w, "impl core::cmp::Eq for {} {{}}", trait_name).unwrap();
+ writeln!(w, "impl core::cmp::PartialEq for {} {{", trait_name).unwrap();
writeln!(w, "\tfn eq(&self, o: &Self) -> bool {{ (self.eq)(self.this_arg, o) }}\n}}").unwrap();
},
("std::hash::Hash", _)|("core::hash::Hash", _) => {
- writeln!(w, "impl std::hash::Hash for {} {{", trait_name).unwrap();
- writeln!(w, "\tfn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {{ hasher.write_u64((self.hash)(self.this_arg)) }}\n}}").unwrap();
+ writeln!(w, "impl core::hash::Hash for {} {{", trait_name).unwrap();
+ writeln!(w, "\tfn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {{ hasher.write_u64((self.hash)(self.this_arg)) }}\n}}").unwrap();
},
("Send", _) => {}, ("Sync", _) => {},
("Clone", _) => {
// Finally, implement the original Rust trait for the newly created mapped trait.
writeln!(w, "\nuse {}::{} as rust{};", types.module_path, t.ident, trait_name).unwrap();
if implementable {
- write!(w, "impl rust{}", t.ident).unwrap();
+ write!(w, "impl").unwrap();
+ maybe_write_lifetime_generics(w, &t.generics, types);
+ write!(w, " rust{}", t.ident).unwrap();
maybe_write_generics(w, &t.generics, types, false);
writeln!(w, " for {} {{", trait_name).unwrap();
impl_trait_for_c!(t, "", types);
writeln!(w, "}}\n").unwrap();
writeln!(w, "// We're essentially a pointer already, or at least a set of pointers, so allow us to be used").unwrap();
writeln!(w, "// directly as a Deref trait in higher-level structs:").unwrap();
- writeln!(w, "impl std::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap();
+ writeln!(w, "impl core::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap();
writeln!(w, "\tfn deref(&self) -> &Self {{\n\t\tself\n\t}}\n}}").unwrap();
}
// If we directly read the original type by its original name, cbindgen hits
// https://github.com/eqrion/cbindgen/issues/286 Thus, instead, we import it as a temporary
// name and then reference it by that name, which works around the issue.
- write!(w, "\nuse {}::{} as native{}Import;\ntype native{} = native{}Import", types.module_path, ident, ident, ident, ident).unwrap();
+ write!(w, "\nuse {}::{} as native{}Import;\npub(crate) type native{} = native{}Import", types.module_path, ident, ident, ident, ident).unwrap();
maybe_write_generics(w, &generics, &types, true);
writeln!(w, ";\n").unwrap();
writeln!(extra_headers, "struct native{}Opaque;\ntypedef struct native{}Opaque LDKnative{};", ident, ident, ident).unwrap();
writeln!(w, "#[no_mangle]\npub extern \"C\" fn {}_free(this_obj: {}) {{ }}", struct_name, struct_name).unwrap();
writeln!(w, "#[allow(unused)]").unwrap();
writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap();
- writeln!(w, "extern \"C\" fn {}_free_void(this_ptr: *mut c_void) {{", struct_name).unwrap();
+ writeln!(w, "pub(crate) extern \"C\" fn {}_free_void(this_ptr: *mut c_void) {{", struct_name).unwrap();
writeln!(w, "\tunsafe {{ let _ = Box::from_raw(this_ptr as *mut native{}); }}\n}}", struct_name).unwrap();
writeln!(w, "#[allow(unused)]").unwrap();
writeln!(w, "impl {} {{", struct_name).unwrap();
writeln!(w, "\tpub(crate) fn take_inner(mut self) -> *mut native{} {{", struct_name).unwrap();
writeln!(w, "\t\tassert!(self.is_owned);").unwrap();
writeln!(w, "\t\tlet ret = ObjOps::untweak_ptr(self.inner);").unwrap();
- writeln!(w, "\t\tself.inner = std::ptr::null_mut();").unwrap();
+ writeln!(w, "\t\tself.inner = core::ptr::null_mut();").unwrap();
writeln!(w, "\t\tret").unwrap();
writeln!(w, "\t}}\n}}").unwrap();
let struct_name = &format!("{}", s.ident);
writeln_opaque(w, &s.ident, struct_name, &s.generics, &s.attrs, types, extra_headers, cpp_headers);
- if let syn::Fields::Named(fields) = &s.fields {
- let mut self_path_segs = syn::punctuated::Punctuated::new();
- self_path_segs.push(s.ident.clone().into());
- let self_path = syn::Path { leading_colon: None, segments: self_path_segs};
- let mut gen_types = GenericTypes::new(Some((types.resolve_path(&self_path, None), &self_path)));
- assert!(gen_types.learn_generics(&s.generics, types));
-
- let mut all_fields_settable = true;
- for field in fields.named.iter() {
- if let syn::Visibility::Public(_) = field.vis {
- let export = export_status(&field.attrs);
+ let mut self_path_segs = syn::punctuated::Punctuated::new();
+ self_path_segs.push(s.ident.clone().into());
+ let self_path = syn::Path { leading_colon: None, segments: self_path_segs};
+ let mut gen_types = GenericTypes::new(Some(types.resolve_path(&self_path, None)));
+ assert!(gen_types.learn_generics(&s.generics, types));
+
+ let mut all_fields_settable = true;
+ macro_rules! define_field {
+ ($new_name: expr, $real_name: expr, $field: expr) => {
+ if let syn::Visibility::Public(_) = $field.vis {
+ let export = export_status(&$field.attrs);
match export {
ExportStatus::Export => {},
ExportStatus::NoExport|ExportStatus::TestOnly => {
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
- if let Some(ident) = &field.ident {
- if let Some(ref_type) = types.create_ownable_reference(&field.ty, Some(&gen_types)) {
- if types.understood_c_type(&ref_type, Some(&gen_types)) {
- writeln_arg_docs(w, &field.attrs, "", types, Some(&gen_types), vec![].drain(..), Some(&ref_type));
- write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: &{}) -> ", struct_name, ident, struct_name).unwrap();
- types.write_c_type(w, &ref_type, Some(&gen_types), true);
- write!(w, " {{\n\tlet mut inner_val = &mut this_ptr.get_native_mut_ref().{};\n\t", ident).unwrap();
- let local_var = types.write_to_c_conversion_new_var(w, &format_ident!("inner_val"), &ref_type, Some(&gen_types), true);
- if local_var { write!(w, "\n\t").unwrap(); }
- types.write_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types), true);
- write!(w, "inner_val").unwrap();
- types.write_to_c_conversion_inline_suffix(w, &ref_type, Some(&gen_types), true);
- writeln!(w, "\n}}").unwrap();
- }
+ if let Some(ref_type) = types.create_ownable_reference(&$field.ty, Some(&gen_types)) {
+ if types.understood_c_type(&ref_type, Some(&gen_types)) {
+ writeln_arg_docs(w, &$field.attrs, "", types, Some(&gen_types), vec![].drain(..), Some(&ref_type));
+ write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: &{}) -> ", struct_name, $new_name, struct_name).unwrap();
+ types.write_c_type(w, &ref_type, Some(&gen_types), true);
+ write!(w, " {{\n\tlet mut inner_val = &mut this_ptr.get_native_mut_ref().{};\n\t", $real_name).unwrap();
+ let local_var = types.write_to_c_conversion_from_ownable_ref_new_var(w, &format_ident!("inner_val"), &ref_type, Some(&gen_types));
+ if local_var { write!(w, "\n\t").unwrap(); }
+ types.write_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types), true);
+ write!(w, "inner_val").unwrap();
+ types.write_to_c_conversion_inline_suffix(w, &ref_type, Some(&gen_types), true);
+ writeln!(w, "\n}}").unwrap();
}
+ }
- if types.understood_c_type(&field.ty, Some(&gen_types)) {
- writeln_arg_docs(w, &field.attrs, "", types, Some(&gen_types), vec![("val".to_owned(), &field.ty)].drain(..), None);
- write!(w, "#[no_mangle]\npub extern \"C\" fn {}_set_{}(this_ptr: &mut {}, mut val: ", struct_name, ident, struct_name).unwrap();
- types.write_c_type(w, &field.ty, Some(&gen_types), false);
- write!(w, ") {{\n\t").unwrap();
- let local_var = types.write_from_c_conversion_new_var(w, &format_ident!("val"), &field.ty, Some(&gen_types));
- if local_var { write!(w, "\n\t").unwrap(); }
- write!(w, "unsafe {{ &mut *ObjOps::untweak_ptr(this_ptr.inner) }}.{} = ", ident).unwrap();
- types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
- write!(w, "val").unwrap();
- types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
- writeln!(w, ";\n}}").unwrap();
- } else { all_fields_settable = false; }
+ if types.understood_c_type(&$field.ty, Some(&gen_types)) {
+ writeln_arg_docs(w, &$field.attrs, "", types, Some(&gen_types), vec![("val".to_owned(), &$field.ty)].drain(..), None);
+ write!(w, "#[no_mangle]\npub extern \"C\" fn {}_set_{}(this_ptr: &mut {}, mut val: ", struct_name, $new_name, struct_name).unwrap();
+ types.write_c_type(w, &$field.ty, Some(&gen_types), false);
+ write!(w, ") {{\n\t").unwrap();
+ let local_var = types.write_from_c_conversion_new_var(w, &format_ident!("val"), &$field.ty, Some(&gen_types));
+ if local_var { write!(w, "\n\t").unwrap(); }
+ write!(w, "unsafe {{ &mut *ObjOps::untweak_ptr(this_ptr.inner) }}.{} = ", $real_name).unwrap();
+ types.write_from_c_conversion_prefix(w, &$field.ty, Some(&gen_types));
+ write!(w, "val").unwrap();
+ types.write_from_c_conversion_suffix(w, &$field.ty, Some(&gen_types));
+ writeln!(w, ";\n}}").unwrap();
} else { all_fields_settable = false; }
} else { all_fields_settable = false; }
}
+ }
- if all_fields_settable {
- // Build a constructor!
- writeln!(w, "/// Constructs a new {} given each field", struct_name).unwrap();
- write!(w, "#[must_use]\n#[no_mangle]\npub extern \"C\" fn {}_new(", struct_name).unwrap();
- for (idx, field) in fields.named.iter().enumerate() {
- if idx != 0 { write!(w, ", ").unwrap(); }
- write!(w, "mut {}_arg: ", field.ident.as_ref().unwrap()).unwrap();
- types.write_c_type(w, &field.ty, Some(&gen_types), false);
- }
- write!(w, ") -> {} {{\n\t", struct_name).unwrap();
+ match &s.fields {
+ syn::Fields::Named(fields) => {
for field in fields.named.iter() {
- let field_ident = format_ident!("{}_arg", field.ident.as_ref().unwrap());
- if types.write_from_c_conversion_new_var(w, &field_ident, &field.ty, Some(&gen_types)) {
- write!(w, "\n\t").unwrap();
+ if let Some(ident) = &field.ident {
+ define_field!(ident, ident, field);
+ } else { all_fields_settable = false; }
+ }
+ }
+ syn::Fields::Unnamed(fields) => {
+ for (idx, field) in fields.unnamed.iter().enumerate() {
+ define_field!(('a' as u8 + idx as u8) as char, ('0' as u8 + idx as u8) as char, field);
+ }
+ }
+ _ => unimplemented!()
+ }
+
+ if all_fields_settable {
+ // Build a constructor!
+ writeln!(w, "/// Constructs a new {} given each field", struct_name).unwrap();
+ write!(w, "#[must_use]\n#[no_mangle]\npub extern \"C\" fn {}_new(", struct_name).unwrap();
+
+ match &s.fields {
+ syn::Fields::Named(fields) => {
+ for (idx, field) in fields.named.iter().enumerate() {
+ if idx != 0 { write!(w, ", ").unwrap(); }
+ write!(w, "mut {}_arg: ", field.ident.as_ref().unwrap()).unwrap();
+ types.write_c_type(w, &field.ty, Some(&gen_types), false);
}
}
- writeln!(w, "{} {{ inner: ObjOps::heap_alloc(native{} {{", struct_name, s.ident).unwrap();
- for field in fields.named.iter() {
- write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
- types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
- write!(w, "{}_arg", field.ident.as_ref().unwrap()).unwrap();
- types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
- writeln!(w, ",").unwrap();
+ syn::Fields::Unnamed(fields) => {
+ for (idx, field) in fields.unnamed.iter().enumerate() {
+ if idx != 0 { write!(w, ", ").unwrap(); }
+ write!(w, "mut {}_arg: ", ('a' as u8 + idx as u8) as char).unwrap();
+ types.write_c_type(w, &field.ty, Some(&gen_types), false);
+ }
}
- writeln!(w, "\t}}), is_owned: true }}\n}}").unwrap();
+ _ => unreachable!()
+ }
+ write!(w, ") -> {} {{\n\t", struct_name).unwrap();
+ match &s.fields {
+ syn::Fields::Named(fields) => {
+ for field in fields.named.iter() {
+ let field_ident = format_ident!("{}_arg", field.ident.as_ref().unwrap());
+ if types.write_from_c_conversion_new_var(w, &field_ident, &field.ty, Some(&gen_types)) {
+ write!(w, "\n\t").unwrap();
+ }
+ }
+ },
+ syn::Fields::Unnamed(fields) => {
+ for (idx, field) in fields.unnamed.iter().enumerate() {
+ let field_ident = format_ident!("{}_arg", ('a' as u8 + idx as u8) as char);
+ if types.write_from_c_conversion_new_var(w, &field_ident, &field.ty, Some(&gen_types)) {
+ write!(w, "\n\t").unwrap();
+ }
+ }
+ },
+ _ => unreachable!()
}
+ write!(w, "{} {{ inner: ObjOps::heap_alloc(", struct_name).unwrap();
+ match &s.fields {
+ syn::Fields::Named(fields) => {
+ writeln!(w, "native{} {{", s.ident).unwrap();
+ for field in fields.named.iter() {
+ write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
+ types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
+ write!(w, "{}_arg", field.ident.as_ref().unwrap()).unwrap();
+ types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
+ writeln!(w, ",").unwrap();
+ }
+ write!(w, "\t}}").unwrap();
+ },
+ syn::Fields::Unnamed(fields) => {
+ assert!(s.generics.lt_token.is_none());
+ writeln!(w, "{} (", types.maybe_resolve_ident(&s.ident).unwrap()).unwrap();
+ for (idx, field) in fields.unnamed.iter().enumerate() {
+ write!(w, "\t\t").unwrap();
+ types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
+ write!(w, "{}_arg", ('a' as u8 + idx as u8) as char).unwrap();
+ types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
+ writeln!(w, ",").unwrap();
+ }
+ write!(w, "\t)").unwrap();
+ },
+ _ => unreachable!()
+ }
+ writeln!(w, "), is_owned: true }}\n}}").unwrap();
}
}
if p.qself.is_some() { unimplemented!(); }
if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
if let Some(resolved_path) = types.maybe_resolve_non_ignored_ident(&ident) {
- let mut gen_types = GenericTypes::new(Some((resolved_path.clone(), &p.path)));
+ if !types.understood_c_path(&p.path) {
+ eprintln!("Not implementing anything for impl {} as the type is not understood (probably C-not exported)", ident);
+ return;
+ }
+
+ let mut gen_types = GenericTypes::new(Some(resolved_path.clone()));
if !gen_types.learn_generics(&i.generics, types) {
eprintln!("Not implementing anything for impl {} due to not understood generics", ident);
return;
// From<> implementation which does all the work to ensure free is handled
// properly. This way we can call this method from deep in the
// type-conversion logic without actually knowing the concrete native type.
+ if !resolved_path.starts_with(types.module_path) {
+ if !first_seg_is_stdlib(resolved_path.split("::").next().unwrap()) {
+ writeln!(w, "use crate::{}::native{} as native{};", resolved_path.rsplitn(2, "::").skip(1).next().unwrap(), ident, ident).unwrap();
+ writeln!(w, "use crate::{};", resolved_path).unwrap();
+ writeln!(w, "use crate::{}_free_void;", resolved_path).unwrap();
+ } else {
+ writeln!(w, "use {} as native{};", resolved_path, ident).unwrap();
+ }
+ }
writeln!(w, "impl From<native{}> for crate::{} {{", ident, full_trait_path).unwrap();
writeln!(w, "\tfn from(obj: native{}) -> Self {{", ident).unwrap();
- writeln!(w, "\t\tlet mut rust_obj = {} {{ inner: ObjOps::heap_alloc(obj), is_owned: true }};", ident).unwrap();
- writeln!(w, "\t\tlet mut ret = {}_as_{}(&rust_obj);", ident, trait_obj.ident).unwrap();
- writeln!(w, "\t\t// We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn").unwrap();
- writeln!(w, "\t\trust_obj.inner = std::ptr::null_mut();").unwrap();
- writeln!(w, "\t\tret.free = Some({}_free_void);", ident).unwrap();
- writeln!(w, "\t\tret\n\t}}\n}}").unwrap();
+ if is_type_unconstructable(&resolved_path) {
+ writeln!(w, "\t\tunreachable!();").unwrap();
+ } else {
+ writeln!(w, "\t\tlet mut rust_obj = {} {{ inner: ObjOps::heap_alloc(obj), is_owned: true }};", ident).unwrap();
+ writeln!(w, "\t\tlet mut ret = {}_as_{}(&rust_obj);", ident, trait_obj.ident).unwrap();
+ writeln!(w, "\t\t// We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn").unwrap();
+ writeln!(w, "\t\trust_obj.inner = core::ptr::null_mut();").unwrap();
+ writeln!(w, "\t\tret.free = Some({}_free_void);", ident).unwrap();
+ writeln!(w, "\t\tret").unwrap();
+ }
+ writeln!(w, "\t}}\n}}").unwrap();
+ if is_type_unconstructable(&resolved_path) {
+ // We don't bother with Struct_as_Trait conversion for types which must
+ // never be instantiated, so just return early.
+ return;
+ }
writeln!(w, "/// Constructs a new {} which calls the relevant methods on this_arg.", trait_obj.ident).unwrap();
writeln!(w, "/// This copies the `inner` pointer in this_arg and thus the returned {} must be freed before this_arg is", trait_obj.ident).unwrap();
writeln!(w, "\t}}\n}}\n").unwrap();
macro_rules! impl_meth {
- ($m: expr, $trait_path: expr, $trait: expr, $indent: expr) => {
+ ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr) => {
let trait_method = $trait.items.iter().filter_map(|item| {
if let syn::TraitItem::Method(t_m) = item { Some(t_m) } else { None }
}).find(|trait_meth| trait_meth.sig.ident == $m.sig.ident).unwrap();
write!(w, "extern \"C\" fn {}_{}_{}(", ident, $trait.ident, $m.sig.ident).unwrap();
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&$m.sig.generics, types));
- write_method_params(w, &$m.sig, "c_void", types, Some(&meth_gen_types), true, true);
- write!(w, " {{\n\t").unwrap();
- write_method_var_decl_body(w, &$m.sig, "", types, Some(&meth_gen_types), false);
- let mut takes_self = false;
+ let mut uncallable_function = false;
for inp in $m.sig.inputs.iter() {
- if let syn::FnArg::Receiver(_) = inp {
- takes_self = true;
+ match inp {
+ syn::FnArg::Typed(arg) => {
+ if types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { continue; }
+ let mut c_type = Vec::new();
+ types.write_c_type(&mut c_type, &*arg.ty, Some(&meth_gen_types), false);
+ if is_type_unconstructable(&String::from_utf8(c_type).unwrap()) {
+ uncallable_function = true;
+ }
+ }
+ _ => {}
}
}
-
- let mut t_gen_args = String::new();
- for (idx, _) in $trait.generics.params.iter().enumerate() {
- if idx != 0 { t_gen_args += ", " };
- t_gen_args += "_"
- }
- if takes_self {
- write!(w, "<native{} as {}<{}>>::{}(unsafe {{ &mut *(this_arg as *mut native{}) }}, ", ident, $trait_path, t_gen_args, $m.sig.ident, ident).unwrap();
+ if uncallable_function {
+ let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ write_method_params(w, &$trait_meth.sig, "c_void", &mut trait_resolver, Some(&meth_gen_types), true, true);
} else {
- write!(w, "<native{} as {}<{}>>::{}(", ident, $trait_path, t_gen_args, $m.sig.ident).unwrap();
+ write_method_params(w, &$m.sig, "c_void", types, Some(&meth_gen_types), true, true);
}
+ write!(w, " {{\n\t").unwrap();
+ if uncallable_function {
+ write!(w, "unreachable!();").unwrap();
+ } else {
+ write_method_var_decl_body(w, &$m.sig, "", types, Some(&meth_gen_types), false);
+ let mut takes_self = false;
+ for inp in $m.sig.inputs.iter() {
+ if let syn::FnArg::Receiver(_) = inp {
+ takes_self = true;
+ }
+ }
- let mut real_type = "".to_string();
- match &$m.sig.output {
- syn::ReturnType::Type(_, rtype) => {
- if let Some(mut remaining_path) = first_seg_self(&*rtype) {
- if let Some(associated_seg) = get_single_remaining_path_seg(&mut remaining_path) {
- real_type = format!("{}", impl_associated_types.get(associated_seg).unwrap());
+ let mut t_gen_args = String::new();
+ for (idx, _) in $trait.generics.params.iter().enumerate() {
+ if idx != 0 { t_gen_args += ", " };
+ t_gen_args += "_"
+ }
+ if takes_self {
+ write!(w, "<native{} as {}<{}>>::{}(unsafe {{ &mut *(this_arg as *mut native{}) }}, ", ident, $trait_path, t_gen_args, $m.sig.ident, ident).unwrap();
+ } else {
+ write!(w, "<native{} as {}<{}>>::{}(", ident, $trait_path, t_gen_args, $m.sig.ident).unwrap();
+ }
+
+ let mut real_type = "".to_string();
+ match &$m.sig.output {
+ syn::ReturnType::Type(_, rtype) => {
+ if let Some(mut remaining_path) = first_seg_self(&*rtype) {
+ if let Some(associated_seg) = get_single_remaining_path_seg(&mut remaining_path) {
+ real_type = format!("{}", impl_associated_types.get(associated_seg).unwrap());
+ }
}
- }
- },
- _ => {},
+ },
+ _ => {},
+ }
+ write_method_call_params(w, &$m.sig, "", types, Some(&meth_gen_types), &real_type, false);
}
- write_method_call_params(w, &$m.sig, "", types, Some(&meth_gen_types), &real_type, false);
write!(w, "\n}}\n").unwrap();
if let syn::ReturnType::Type(_, rtype) = &$m.sig.output {
if let syn::Type::Reference(r) = &**rtype {
}
}
- for item in i.items.iter() {
+ 'impl_item_loop: for item in i.items.iter() {
match item {
syn::ImplItem::Method(m) => {
- impl_meth!(m, full_trait_path, trait_obj, "");
+ for trait_item in trait_obj.items.iter() {
+ match trait_item {
+ syn::TraitItem::Method(meth) => {
+ if meth.sig.ident == m.sig.ident {
+ impl_meth!(m, meth, full_trait_path, trait_obj, "");
+ continue 'impl_item_loop;
+ }
+ },
+ _ => {},
+ }
+ }
+ unreachable!();
},
syn::ImplItem::Type(_) => {},
_ => unimplemented!(),
writeln!(w, "}}").unwrap();
}
write!(w, "\n").unwrap();
- } else if path_matches_nongeneric(&trait_path.1, &["From"]) {
+ return;
+ }
+ if is_type_unconstructable(&resolved_path) {
+ // Don't bother exposing trait implementations for objects which cannot be
+ // instantiated.
+ return;
+ }
+ if path_matches_nongeneric(&trait_path.1, &["From"]) {
} else if path_matches_nongeneric(&trait_path.1, &["Default"]) {
writeln!(w, "/// Creates a \"default\" {}. See struct and individual field documentaiton for details on which values are used.", ident).unwrap();
write!(w, "#[must_use]\n#[no_mangle]\npub extern \"C\" fn {}_default() -> {} {{\n", ident, ident).unwrap();
let ref_type: syn::Type = syn::parse_quote!(&#path);
assert!(!types.write_to_c_conversion_new_var(w, &format_ident!("a"), &*i.self_ty, Some(&gen_types), false), "We don't support new var conversions when comparing equality");
- writeln!(w, "\t// Note that we'd love to use std::collections::hash_map::DefaultHasher but it's not in core").unwrap();
+ writeln!(w, "\t// Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core").unwrap();
writeln!(w, "\t#[allow(deprecated)]").unwrap();
writeln!(w, "\tlet mut hasher = core::hash::SipHasher::new();").unwrap();
- write!(w, "\tstd::hash::Hash::hash(").unwrap();
+ write!(w, "\tcore::hash::Hash::hash(").unwrap();
types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
write!(w, "o").unwrap();
types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
writeln!(w, ", &mut hasher);").unwrap();
- writeln!(w, "\tstd::hash::Hasher::finish(&hasher)\n}}").unwrap();
+ writeln!(w, "\tcore::hash::Hasher::finish(&hasher)\n}}").unwrap();
} else if (path_matches_nongeneric(&trait_path.1, &["core", "clone", "Clone"]) || path_matches_nongeneric(&trait_path.1, &["Clone"])) &&
types.c_type_has_inner_from_path(&resolved_path) {
writeln!(w, "impl Clone for {} {{", ident).unwrap();
writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
writeln!(w, "\t\tSelf {{").unwrap();
- writeln!(w, "\t\t\tinner: if <*mut native{}>::is_null(self.inner) {{ std::ptr::null_mut() }} else {{", ident).unwrap();
+ writeln!(w, "\t\t\tinner: if <*mut native{}>::is_null(self.inner) {{ core::ptr::null_mut() }} else {{", ident).unwrap();
writeln!(w, "\t\t\t\tObjOps::heap_alloc(unsafe {{ &*ObjOps::untweak_ptr(self.inner) }}.clone()) }},").unwrap();
writeln!(w, "\t\t\tis_owned: true,").unwrap();
writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_{}(", ident, m.sig.ident).unwrap();
let ret_type = match &declared_type {
DeclType::MirroredEnum => format!("{}", ident),
- DeclType::StructImported => format!("{}", ident),
+ DeclType::StructImported {..} => format!("{}", ident),
_ => unimplemented!(),
};
write_method_params(w, &m.sig, &ret_type, types, Some(&meth_gen_types), false, true);
} else {
match &declared_type {
DeclType::MirroredEnum => write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap(),
- DeclType::StructImported => {
+ DeclType::StructImported {..} => {
if takes_owned_self {
write!(w, "(*unsafe {{ Box::from_raw(this_arg.take_inner()) }}).{}(", m.sig.ident).unwrap();
} else if takes_mut_self {
writeln_fn_docs(w, &f.attrs, "", types, Some(&gen_types), f.sig.inputs.iter(), &f.sig.output);
write!(w, "#[no_mangle]\npub extern \"C\" fn {}(", f.sig.ident).unwrap();
+
+
write_method_params(w, &f.sig, "", types, Some(&gen_types), false, true);
write!(w, " {{\n\t").unwrap();
write_method_var_decl_body(w, &f.sig, "", types, Some(&gen_types), false);
- write!(w, "{}::{}(", types.module_path, f.sig.ident).unwrap();
+ write!(w, "{}::{}", types.module_path, f.sig.ident).unwrap();
+
+ let mut function_generic_args = Vec::new();
+ maybe_write_generics(&mut function_generic_args, &f.sig.generics, types, true);
+ if !function_generic_args.is_empty() {
+ write!(w, "::{}", String::from_utf8(function_generic_args).unwrap()).unwrap();
+ }
+ write!(w, "(").unwrap();
+
write_method_call_params(w, &f.sig, "", types, Some(&gen_types), "", false);
writeln!(w, "\n}}\n").unwrap();
}
writeln!(out, "#![allow(unused_braces)]").unwrap();
// TODO: We need to map deny(missing_docs) in the source crate(s)
//writeln!(out, "#![deny(missing_docs)]").unwrap();
+
+ writeln!(out, "#![cfg_attr(not(feature = \"std\"), no_std)]").unwrap();
+ writeln!(out, "#[cfg(not(any(feature = \"std\", feature = \"no-std\")))]").unwrap();
+ writeln!(out, "compile_error!(\"at least one of the `std` or `no-std` features must be enabled\");").unwrap();
+ writeln!(out, "extern crate alloc;").unwrap();
+
writeln!(out, "pub mod version;").unwrap();
writeln!(out, "pub mod c_types;").unwrap();
writeln!(out, "pub mod bitcoin;").unwrap();
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
let struct_path = format!("{}::{}", module, s.ident);
- crate_types.opaques.insert(struct_path, &s.ident);
+ crate_types.opaques.insert(struct_path, (&s.ident, &s.generics));
}
},
syn::Item::Trait(t) => {
hash_map::Entry::Vacant(e) => { e.insert(vec![(path_obj, args_obj)]); },
}
- crate_types.opaques.insert(type_path, t_ident);
+ crate_types.opaques.insert(type_path, (t_ident, &t.generics));
},
_ => {
crate_types.type_aliases.insert(type_path, import_resolver.resolve_imported_refs((*t.ty).clone()));
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
let enum_path = format!("{}::{}", module, e.ident);
- crate_types.opaques.insert(enum_path, &e.ident);
+ crate_types.opaques.insert(enum_path, (&e.ident, &e.generics));
}
},
syn::Item::Enum(e) => {
syn::Item::Impl(i) => {
if let &syn::Type::Path(ref p) = &*i.self_ty {
if let Some(trait_path) = i.trait_.as_ref() {
- if path_matches_nongeneric(&trait_path.1, &["core", "clone", "Clone"]) {
+ if path_matches_nongeneric(&trait_path.1, &["core", "clone", "Clone"]) ||
+ path_matches_nongeneric(&trait_path.1, &["Clone"]) {
if let Some(full_path) = import_resolver.maybe_resolve_path(&p.path, None) {
crate_types.set_clonable("crate::".to_owned() + &full_path);
}
let mut derived_templates = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
.open(&args[2]).expect("Unable to open new header file");
+ writeln!(&mut derived_templates, "{}", DEFAULT_IMPORTS).unwrap();
let mut header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
.open(&args[3]).expect("Unable to open new header file");
let mut cpp_header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
writeln!(header_file, "#endif").unwrap();
writeln!(cpp_header_file, "#include <string.h>\nnamespace LDK {{").unwrap();
+ // Write a few manually-defined types into the C++ header file
+ write_cpp_wrapper(&mut cpp_header_file, "Str", true, None);
+
// First parse the full crate's ASTs, caching them so that we can hold references to the AST
// objects in other datastructures:
let mut lib_src = String::new();
projects / ldk-c-bindings / blobdiff