use types::*;
use blocks::*;
-const DEFAULT_IMPORTS: &'static str = "\nuse std::str::FromStr;\nuse std::ffi::c_void;\nuse core::convert::Infallible;\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};
+";
+
+
+/// str.rsplit_once but with an older MSRV
+fn rsplit_once<'a>(inp: &'a str, pattern: &str) -> Option<(&'a str, &'a str)> {
+ let mut iter = inp.rsplitn(2, pattern);
+ let second_entry = iter.next().unwrap();
+ Some((iter.next().unwrap(), second_entry))
+}
// *************************************
// *** Manually-expanded conversions ***
let full_obj_path;
let mut has_inner = false;
if let syn::Type::Path(ref p) = for_ty {
- if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
- for_obj = format!("{}", ident);
- full_obj_path = for_obj.clone();
- has_inner = types.c_type_has_inner_from_path(&types.resolve_path(&p.path, Some(generics)));
- } else { return; }
+ let resolved_path = types.resolve_path(&p.path, Some(generics));
+ for_obj = format!("{}", p.path.segments.last().unwrap().ident);
+ full_obj_path = format!("crate::{}", resolved_path);
+ has_inner = types.c_type_has_inner_from_path(&resolved_path);
} else {
// We assume that anything that isn't a Path is somehow a generic that ends up in our
// derived-types module.
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();
let mut arg_conv = Vec::new();
if t == "lightning::util::ser::ReadableArgs" {
- write!(w, ", arg: ").unwrap();
assert!(trait_path.leading_colon.is_none());
let args_seg = trait_path.segments.iter().last().unwrap();
assert_eq!(format!("{}", args_seg.ident), "ReadableArgs");
if let syn::PathArguments::AngleBracketed(args) = &args_seg.arguments {
assert_eq!(args.args.len(), 1);
if let syn::GenericArgument::Type(args_ty) = args.args.iter().next().unwrap() {
- types.write_c_type(w, args_ty, Some(generics), false);
+ macro_rules! write_arg_conv {
+ ($ty: expr, $arg_name: expr) => {
+ write!(w, ", {}: ", $arg_name).unwrap();
+ types.write_c_type(w, $ty, Some(generics), false);
+
+ write!(&mut arg_conv, "\t").unwrap();
+ if types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("{}", $arg_name), &$ty, Some(generics)) {
+ write!(&mut arg_conv, "\n\t").unwrap();
+ }
- assert!(!types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("arg"), &args_ty, Some(generics)));
+ write!(&mut arg_conv, "let {}_conv = ", $arg_name).unwrap();
+ types.write_from_c_conversion_prefix(&mut arg_conv, &$ty, Some(generics));
+ write!(&mut arg_conv, "{}", $arg_name).unwrap();
+ types.write_from_c_conversion_suffix(&mut arg_conv, &$ty, Some(generics));
+ write!(&mut arg_conv, ";\n").unwrap();
+ }
+ }
- write!(&mut arg_conv, "\tlet arg_conv = ").unwrap();
- types.write_from_c_conversion_prefix(&mut arg_conv, &args_ty, Some(generics));
- write!(&mut arg_conv, "arg").unwrap();
- types.write_from_c_conversion_suffix(&mut arg_conv, &args_ty, Some(generics));
+ if let syn::Type::Tuple(tup) = args_ty {
+ // Crack open tuples and make them separate arguments instead of
+ // converting the full tuple. This makes it substantially easier to
+ // reason about things like references in the tuple fields.
+ let mut arg_conv_res = Vec::new();
+ for (idx, elem) in tup.elems.iter().enumerate() {
+ let arg_name = format!("arg_{}", ('a' as u8 + idx as u8) as char);
+ write_arg_conv!(elem, arg_name);
+ write!(&mut arg_conv_res, "{}_conv{}", arg_name, if idx != tup.elems.len() - 1 { ", " } else { "" }).unwrap();
+ }
+ writeln!(&mut arg_conv, "\tlet arg_conv = ({});", String::from_utf8(arg_conv_res).unwrap()).unwrap();
+ } else {
+ write_arg_conv!(args_ty, "arg");
+ }
} 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, "\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();
ExportStatus::TestOnly => continue,
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
- if m.default.is_some() { unimplemented!(); }
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, types));
match item {
syn::TraitItem::Method(m) => {
if let ExportStatus::TestOnly = export_status(&m.attrs) { continue; }
- if m.default.is_some() { unimplemented!(); }
if m.sig.constness.is_some() || m.sig.asyncness.is_some() || m.sig.unsafety.is_some() ||
m.sig.abi.is_some() || m.sig.variadic.is_some() {
- unimplemented!();
+ panic!("1");
}
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, $type_resolver));
for inp in m.sig.inputs.iter() {
match inp {
syn::FnArg::Receiver(recv) => {
- if !recv.attrs.is_empty() || recv.reference.is_none() { unimplemented!(); }
+ if !recv.attrs.is_empty() || recv.reference.is_none() { panic!("2"); }
write!(w, "&").unwrap();
if let Some(lft) = &recv.reference.as_ref().unwrap().1 {
write!(w, "'{} ", lft.ident).unwrap();
}
},
syn::FnArg::Typed(arg) => {
- if !arg.attrs.is_empty() { unimplemented!(); }
+ if !arg.attrs.is_empty() { panic!("3"); }
match &*arg.pat {
syn::Pat::Ident(ident) => {
if !ident.attrs.is_empty() || ident.by_ref.is_some() ||
ident.mutability.is_some() || ident.subpat.is_some() {
- unimplemented!();
+ panic!("4");
}
write!(w, ", mut {}{}: ", if $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
}
- _ => unimplemented!(),
+ _ => panic!("5"),
}
$type_resolver.write_rust_type(w, Some(&gen_types), &*arg.ty);
}
write!(w, " {{\n\t\t").unwrap();
match export_status(&m.attrs) {
ExportStatus::NoExport => {
- unimplemented!();
+ panic!("6");
},
_ => {},
}
writeln!(w, "\n\t}}").unwrap();
},
&syn::TraitItem::Type(ref t) => {
- if t.default.is_some() || t.generics.lt_token.is_some() { unimplemented!(); }
+ if t.default.is_some() || t.generics.lt_token.is_some() { panic!("10"); }
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 { panic!("11"); }
+ }
+ break;
+ },
+ syn::TypeParamBound::Lifetime(_) => {},
+ }
}
- if bounds_iter.next().is_some() { unimplemented!(); }
},
- _ => unimplemented!(),
+ _ => panic!("12"),
}
}
}
// 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", _) => {
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();
}
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)));
- 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 let &syn::Type::Path(ref p) = &*i.self_ty {
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 ident = &p.path.segments.last().unwrap().ident;
+ if let Some(resolved_path) = types.maybe_resolve_path(&p.path, None) {
+ if types.crate_types.opaques.contains_key(&resolved_path) || types.crate_types.mirrored_enums.contains_key(&resolved_path) ||
+ // At least for core::infallible::Infallible we need to support mapping an
+ // out-of-crate trait implementation.
+ (types.understood_c_path(&p.path) && first_seg_is_stdlib(resolved_path.split("::").next().unwrap())) {
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;
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\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}}\n").unwrap();
macro_rules! impl_meth {
- ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr) => {
+ ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr, $types: 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));
+ assert!(meth_gen_types.learn_generics(&$m.sig.generics, $types));
let mut uncallable_function = false;
for inp in $m.sig.inputs.iter() {
match inp {
syn::FnArg::Typed(arg) => {
- if types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { continue; }
+ 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);
+ $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;
}
}
}
if uncallable_function {
- let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ 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_method_params(w, &$m.sig, "c_void", types, Some(&meth_gen_types), true, true);
+ 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);
+ 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 {
},
_ => {},
}
- 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 {
writeln!(w, "\t// This is a bit race-y in the general case, but for our specific use-cases today, we're safe").unwrap();
writeln!(w, "\t// Specifically, we must ensure that the first time we're called it can never be in parallel").unwrap();
write!(w, "\tif ").unwrap();
- types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident));
+ $types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident));
writeln!(w, " {{").unwrap();
writeln!(w, "\t\tunsafe {{ &mut *(trait_self_arg as *const {} as *mut {}) }}.{} = {}_{}_{}(trait_self_arg.this_arg);", $trait.ident, $trait.ident, $m.sig.ident, ident, $trait.ident, $m.sig.ident).unwrap();
writeln!(w, "\t}}").unwrap();
}
}
- 'impl_item_loop: for item in i.items.iter() {
- match item {
- syn::ImplItem::Method(m) => {
- for trait_item in trait_obj.items.iter() {
- match trait_item {
- syn::TraitItem::Method(meth) => {
+ 'impl_item_loop: for trait_item in trait_obj.items.iter() {
+ match trait_item {
+ syn::TraitItem::Method(meth) => {
+ for item in i.items.iter() {
+ match item {
+ syn::ImplItem::Method(m) => {
if meth.sig.ident == m.sig.ident {
- impl_meth!(m, meth, full_trait_path, trait_obj, "");
+ impl_meth!(m, meth, full_trait_path, trait_obj, "", types);
continue 'impl_item_loop;
}
},
- _ => {},
+ syn::ImplItem::Type(_) => {},
+ _ => unimplemented!(),
}
}
- unreachable!();
+ assert!(meth.default.is_some());
+ let old_gen_types = gen_types;
+ gen_types = GenericTypes::new(Some(resolved_path.clone()));
+ let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ impl_meth!(meth, meth, full_trait_path, trait_obj, "", &mut trait_resolver);
+ gen_types = old_gen_types;
},
- syn::ImplItem::Type(_) => {},
- _ => unimplemented!(),
+ _ => {},
}
}
if requires_clone {
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();
writeln!(w, "\torig.clone()").unwrap();
writeln!(w, "}}").unwrap();
} else if path_matches_nongeneric(&trait_path.1, &["FromStr"]) {
- if let Some(container) = types.get_c_mangled_container_type(
- vec![&*i.self_ty, &syn::Type::Tuple(syn::TypeTuple { paren_token: Default::default(), elems: syn::punctuated::Punctuated::new() })],
- Some(&gen_types), "Result") {
+ let mut err_opt = None;
+ for item in i.items.iter() {
+ match item {
+ syn::ImplItem::Type(ty) if format!("{}", ty.ident) == "Err" => {
+ err_opt = Some(&ty.ty);
+ },
+ _ => {}
+ }
+ }
+ let err_ty = err_opt.unwrap();
+ if let Some(container) = types.get_c_mangled_container_type(vec![&*i.self_ty, &err_ty], Some(&gen_types), "Result") {
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Read a {} object from a string", ident).unwrap();
writeln!(w, "pub extern \"C\" fn {}_from_str(s: crate::c_types::Str) -> {} {{", ident, container).unwrap();
writeln!(w, "\tmatch {}::from_str(s.into_str()) {{", resolved_path).unwrap();
+
writeln!(w, "\t\tOk(r) => {{").unwrap();
let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("r"), &*i.self_ty, Some(&gen_types), false);
write!(w, "\t\t\tcrate::c_types::CResultTempl::ok(\n\t\t\t\t").unwrap();
write!(w, "{}r", if new_var { "local_" } else { "" }).unwrap();
types.write_to_c_conversion_inline_suffix(w, &*i.self_ty, Some(&gen_types), false);
writeln!(w, "\n\t\t\t)\n\t\t}},").unwrap();
- writeln!(w, "\t\tErr(e) => crate::c_types::CResultTempl::err(()),").unwrap();
+
+ writeln!(w, "\t\tErr(e) => {{").unwrap();
+ let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("e"), &err_ty, Some(&gen_types), false);
+ write!(w, "\t\t\tcrate::c_types::CResultTempl::err(\n\t\t\t\t").unwrap();
+ types.write_to_c_conversion_inline_prefix(w, &err_ty, Some(&gen_types), false);
+ write!(w, "{}e", if new_var { "local_" } else { "" }).unwrap();
+ types.write_to_c_conversion_inline_suffix(w, &err_ty, Some(&gen_types), false);
+ writeln!(w, "\n\t\t\t)\n\t\t}},").unwrap();
+
writeln!(w, "\t}}.into()\n}}").unwrap();
}
} else if path_matches_nongeneric(&trait_path.1, &["Display"]) {
let self_ty = &i.self_ty;
let ref_type: syn::Type = syn::parse_quote!(&#self_ty);
let new_var = types.write_from_c_conversion_new_var(w, &format_ident!("o"), &ref_type, Some(&gen_types));
- write!(w, "\tformat!(\"{{}}\", ").unwrap();
+ write!(w, "\talloc::format!(\"{{}}\", ").unwrap();
types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
write!(w, "{}o", if new_var { "local_" } else { "" }).unwrap();
types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types);
}
} else {
- let declared_type = (*types.get_declared_type(&ident).unwrap()).clone();
+ let is_opaque = types.crate_types.opaques.contains_key(&resolved_path);
+ let is_mirrored_enum = types.crate_types.mirrored_enums.contains_key(&resolved_path);
for item in i.items.iter() {
match item {
syn::ImplItem::Method(m) => {
writeln!(w, "#[must_use]").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),
- _ => unimplemented!(),
- };
+ let ret_type = format!("crate::{}", resolved_path);
write_method_params(w, &m.sig, &ret_type, types, Some(&meth_gen_types), false, true);
write!(w, " {{\n\t").unwrap();
write_method_var_decl_body(w, &m.sig, "", types, Some(&meth_gen_types), false);
if !takes_mut_self && !takes_self {
write!(w, "{}::{}(", resolved_path, m.sig.ident).unwrap();
} else {
- match &declared_type {
- DeclType::MirroredEnum => write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap(),
- 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 {
- write!(w, "unsafe {{ &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut native{})) }}.{}(", ident, m.sig.ident).unwrap();
- } else {
- write!(w, "unsafe {{ &*ObjOps::untweak_ptr(this_arg.inner) }}.{}(", m.sig.ident).unwrap();
- }
- },
- _ => unimplemented!(),
+ if is_mirrored_enum {
+ write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap();
+ } else if is_opaque {
+ if takes_owned_self {
+ write!(w, "(*unsafe {{ Box::from_raw(this_arg.take_inner()) }}).{}(", m.sig.ident).unwrap();
+ } else if takes_mut_self {
+ write!(w, "unsafe {{ &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut crate::{}::native{})) }}.{}(", rsplit_once(&resolved_path, "::").unwrap().0, ident, m.sig.ident).unwrap();
+ } else {
+ write!(w, "unsafe {{ &*ObjOps::untweak_ptr(this_arg.inner) }}.{}(", m.sig.ident).unwrap();
+ }
+ } else {
+ unimplemented!();
}
}
write_method_call_params(w, &m.sig, "", types, Some(&meth_gen_types), &ret_type, false);
}
} else if let Some(resolved_path) = types.maybe_resolve_ident(&ident) {
if let Some(aliases) = types.crate_types.reverse_alias_map.get(&resolved_path).cloned() {
- 'alias_impls: for (alias, arguments) in aliases {
- let alias_resolved = types.resolve_path(&alias, None);
+ let mut gen_types = Some(GenericTypes::new(Some(resolved_path.clone())));
+ if !gen_types.as_mut().unwrap().learn_generics(&i.generics, types) {
+ gen_types = None;
+ }
+ let alias_module = rsplit_once(&resolved_path, "::").unwrap().0;
+
+ 'alias_impls: for (alias_resolved, arguments) in aliases {
+ let mut new_ty_generics = Vec::new();
+ let mut need_generics = false;
+
+ let alias_resolver_override;
+ let alias_resolver = if alias_module != types.module_path {
+ alias_resolver_override = ImportResolver::new(types.types.crate_name, &types.crate_types.lib_ast.dependencies,
+ alias_module, &types.crate_types.lib_ast.modules.get(alias_module).unwrap().items);
+ &alias_resolver_override
+ } else { &types.types };/*.maybe_resolve_path(&alias, None).unwrap();*/
for (idx, gen) in i.generics.params.iter().enumerate() {
match gen {
syn::GenericParam::Type(type_param) => {
if let syn::PathArguments::AngleBracketed(ref t) = &arguments {
assert!(idx < t.args.len());
if let syn::GenericArgument::Type(syn::Type::Path(p)) = &t.args[idx] {
- let generic_arg = types.resolve_path(&p.path, None);
- let generic_bound = types.resolve_path(&trait_bound.path, None);
- if let Some(traits_impld) = types.crate_types.trait_impls.get(&generic_arg) {
- for trait_impld in traits_impld {
- if *trait_impld == generic_bound { continue 'bounds_check; }
+ if let Some(generic_arg) = alias_resolver.maybe_resolve_path(&p.path, None) {
+
+ new_ty_generics.push((type_param.ident.clone(), syn::Type::Path(p.clone())));
+ let generic_bound = types.maybe_resolve_path(&trait_bound.path, None)
+ .unwrap_or_else(|| format!("{}::{}", types.module_path, single_ident_generic_path_to_ident(&trait_bound.path).unwrap()));
+ if let Some(traits_impld) = types.crate_types.trait_impls.get(&generic_arg) {
+ for trait_impld in traits_impld {
+ if *trait_impld == generic_bound { continue 'bounds_check; }
+ }
+ eprintln!("struct {}'s generic arg {} didn't match bound {}", alias_resolved, generic_arg, generic_bound);
+ continue 'alias_impls;
+ } else {
+ eprintln!("struct {}'s generic arg {} didn't match bound {}", alias_resolved, generic_arg, generic_bound);
+ continue 'alias_impls;
}
- eprintln!("struct {}'s generic arg {} didn't match bound {}", alias_resolved, generic_arg, generic_bound);
- continue 'alias_impls;
+ } else if gen_types.is_some() {
+ new_ty_generics.push((type_param.ident.clone(),
+ gen_types.as_ref().resolve_type(&syn::Type::Path(p.clone())).clone()));
+ need_generics = true;
} else {
- eprintln!("struct {}'s generic arg {} didn't match bound {}", alias_resolved, generic_arg, generic_bound);
- continue 'alias_impls;
+ unimplemented!();
}
} else { unimplemented!(); }
} else { unimplemented!(); }
syn::GenericParam::Const(_) => unimplemented!(),
}
}
+ let mut params = syn::punctuated::Punctuated::new();
+ let alias = string_path_to_syn_path(&alias_resolved);
+ let real_aliased =
+ if need_generics {
+ let alias_generics = types.crate_types.opaques.get(&alias_resolved).unwrap().1;
+
+ // If we need generics on the alias, create impl generic bounds...
+ assert_eq!(new_ty_generics.len(), i.generics.params.len());
+ let mut args = syn::punctuated::Punctuated::new();
+ for (ident, param) in new_ty_generics.drain(..) {
+ // TODO: We blindly assume that generics in the type alias and
+ // the aliased type have the same names, which we really shouldn't.
+ if alias_generics.params.iter().any(|generic|
+ if let syn::GenericParam::Type(t) = generic { t.ident == ident } else { false })
+ {
+ args.push(parse_quote!(#ident));
+ }
+ params.push(syn::GenericParam::Type(syn::TypeParam {
+ attrs: Vec::new(),
+ ident,
+ colon_token: None,
+ bounds: syn::punctuated::Punctuated::new(),
+ eq_token: Some(syn::token::Eq(Span::call_site())),
+ default: Some(param),
+ }));
+ }
+ // ... and swap the last segment of the impl self_ty to use the generic bounds.
+ let mut res = alias.clone();
+ res.segments.last_mut().unwrap().arguments = syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
+ colon2_token: None,
+ lt_token: syn::token::Lt(Span::call_site()),
+ args,
+ gt_token: syn::token::Gt(Span::call_site()),
+ });
+ res
+ } else { alias.clone() };
let aliased_impl = syn::ItemImpl {
attrs: i.attrs.clone(),
brace_token: syn::token::Brace(Span::call_site()),
defaultness: None,
generics: syn::Generics {
lt_token: None,
- params: syn::punctuated::Punctuated::new(),
+ params,
gt_token: None,
where_clause: None,
},
impl_token: syn::Token),
items: i.items.clone(),
- self_ty: Box::new(syn::Type::Path(syn::TypePath { qself: None, path: alias.clone() })),
+ self_ty: Box::new(syn::Type::Path(syn::TypePath { qself: None, path: real_aliased })),
trait_: i.trait_.clone(),
unsafety: None,
};
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();
}
match item {
syn::Item::Mod(m) => convert_priv_mod(w, libast, crate_types, out_dir, &format!("{}::{}", mod_path, module.ident), m),
syn::Item::Impl(i) => {
- if let &syn::Type::Path(ref p) = &*i.self_ty {
- if p.path.get_ident().is_some() {
- writeln_impl(w, i, &mut types);
- }
- }
+ writeln_impl(w, i, &mut types);
},
_ => {},
}
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 mut process_alias = true;
- for tok in t.generics.params.iter() {
- if let syn::GenericParam::Lifetime(_) = tok {}
- else { process_alias = false; }
- }
- if process_alias {
- match &*t.ty {
- syn::Type::Path(_) =>
- writeln_opaque(&mut out, &t.ident, &format!("{}", t.ident), &t.generics, &t.attrs, &type_resolver, header_file, cpp_header_file),
- _ => {}
- }
+ match &*t.ty {
+ syn::Type::Path(p) => {
+ let real_ty = type_resolver.resolve_path(&p.path, None);
+ let real_generic_bounds = type_resolver.crate_types.opaques.get(&real_ty).map(|t| t.1).or(
+ type_resolver.crate_types.priv_structs.get(&real_ty).map(|r| *r)).unwrap();
+ let mut resolved_generics = t.generics.clone();
+
+ // Assume blindly that the bounds in the struct definition where
+ // clause matches any equivalent bounds on the type alias.
+ assert!(resolved_generics.where_clause.is_none());
+ resolved_generics.where_clause = real_generic_bounds.where_clause.clone();
+
+ if let syn::PathArguments::AngleBracketed(real_generics) = &p.path.segments.last().unwrap().arguments {
+ for (real_idx, real_param) in real_generics.args.iter().enumerate() {
+ if let syn::GenericArgument::Type(syn::Type::Path(real_param_path)) = real_param {
+ for param in resolved_generics.params.iter_mut() {
+ if let syn::GenericParam::Type(type_param) = param {
+ if Some(&type_param.ident) == real_param_path.path.get_ident() {
+ if let syn::GenericParam::Type(real_type_param) = &real_generic_bounds.params[real_idx] {
+ type_param.bounds = real_type_param.bounds.clone();
+ type_param.default = real_type_param.default.clone();
+
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ writeln_opaque(&mut out, &t.ident, &format!("{}", t.ident), &resolved_generics, &t.attrs, &type_resolver, header_file, cpp_header_file)},
+ _ => {}
}
}
},
match item {
syn::Item::Struct(s) => {
if let syn::Visibility::Public(_) = s.vis {
+ let struct_path = format!("{}::{}", module, s.ident);
match export_status(&s.attrs) {
ExportStatus::Export => {},
- ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+ ExportStatus::NoExport|ExportStatus::TestOnly => {
+ crate_types.priv_structs.insert(struct_path, &s.generics);
+ continue
+ },
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) => {
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
let type_path = format!("{}::{}", module, t.ident);
- let mut process_alias = true;
- for tok in t.generics.params.iter() {
- if let syn::GenericParam::Lifetime(_) = tok {}
- else { process_alias = false; }
- }
- if process_alias {
- match &*t.ty {
- syn::Type::Path(p) => {
- let t_ident = &t.ident;
-
- // If its a path with no generics, assume we don't map the aliased type and map it opaque
- let path_obj = parse_quote!(#t_ident);
- let args_obj = p.path.segments.last().unwrap().arguments.clone();
- match crate_types.reverse_alias_map.entry(import_resolver.maybe_resolve_path(&p.path, None).unwrap()) {
- hash_map::Entry::Occupied(mut e) => { e.get_mut().push((path_obj, args_obj)); },
- hash_map::Entry::Vacant(e) => { e.insert(vec![(path_obj, args_obj)]); },
- }
-
- crate_types.opaques.insert(type_path, t_ident);
- },
- _ => {
- crate_types.type_aliases.insert(type_path, import_resolver.resolve_imported_refs((*t.ty).clone()));
+ match &*t.ty {
+ syn::Type::Path(p) => {
+ // If its a path with no generics, assume we don't map the aliased type and map it opaque
+ let args_obj = p.path.segments.last().unwrap().arguments.clone();
+ match crate_types.reverse_alias_map.entry(import_resolver.maybe_resolve_path(&p.path, None).unwrap()) {
+ hash_map::Entry::Occupied(mut e) => { e.get_mut().push((type_path.clone(), args_obj)); },
+ hash_map::Entry::Vacant(e) => { e.insert(vec![(type_path.clone(), args_obj)]); },
}
+
+ 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) => {
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)
projects / ldk-c-bindings / blobdiff