/// Write out the impl block for a defined trait struct which has a supertrait
fn do_write_impl_trait<W: std::io::Write>(w: &mut W, trait_path: &str, _trait_name: &syn::Ident, for_obj: &str) {
-eprintln!("{}", trait_path);
match trait_path {
"lightning::util::ser::Writeable" => {
writeln!(w, "impl {} for {} {{", trait_path, for_obj).unwrap();
}
} } }
+macro_rules! get_module_type_resolver {
+ ($module: expr, $crate_libs: expr, $crate_types: expr) => { {
+ let module: &str = &$module;
+ let mut module_iter = module.rsplitn(2, "::");
+ module_iter.next().unwrap();
+ let module = module_iter.next().unwrap();
+ let imports = ImportResolver::new(module.splitn(2, "::").next().unwrap(), &$crate_types.lib_ast.dependencies,
+ module, &$crate_types.lib_ast.modules.get(module).unwrap().items);
+ TypeResolver::new(module, imports, $crate_types)
+ } }
+}
+
/// Prints a C-mapped trait object containing a void pointer and a jump table for each function in
/// the original trait.
/// Implements the native Rust trait and relevant parent traits for the new C-mapped trait.
writeln_docs(w, &t.attrs, "");
let mut gen_types = GenericTypes::new(None);
+
+ // Add functions which may be required for supertrait implementations.
+ // Due to borrow checker limitations, we only support one in-crate supertrait here.
+ let supertrait_name;
+ let supertrait_resolver;
+ walk_supertraits!(t, Some(&types), (
+ (s, _i) => {
+ if let Some(supertrait) = types.crate_types.traits.get(s) {
+ supertrait_name = s.to_string();
+ supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_libs, types.crate_types);
+ gen_types.learn_associated_types(&supertrait, &supertrait_resolver);
+ break;
+ }
+ }
+ ) );
+
assert!(gen_types.learn_generics(&t.generics, types));
gen_types.learn_associated_types(&t, types);
Some(format!("\t/**\n\t * {}\n\t * {}\n\t */\n", hash_docs_a, hash_docs_b))));
},
("Send", _) => {}, ("Sync", _) => {},
+ ("std::fmt::Debug", _)|("core::fmt::Debug", _) => {
+ let debug_docs = "Return a human-readable \"debug\" string describing this object";
+ writeln!(w, "\t/// {}", debug_docs).unwrap();
+ writeln!(w, "\tpub debug_str: extern \"C\" fn (this_arg: *const c_void) -> crate::c_types::Str,").unwrap();
+ generated_fields.push(("debug_str".to_owned(), None,
+ Some(format!("\t/**\n\t * {}\n\t */\n", debug_docs))));
+ },
(s, i) => {
// TODO: Both of the below should expose supertrait methods in C++, but doing so is
// nontrivial.
writeln!(w, "\t\t{}_clone(self)", trait_name).unwrap();
writeln!(w, "\t}}\n}}").unwrap();
},
+ ("std::fmt::Debug", _)|("core::fmt::Debug", _) => {
+ writeln!(w, "impl core::fmt::Debug for {} {{", trait_name).unwrap();
+ writeln!(w, "\tfn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {{").unwrap();
+ writeln!(w, "\t\tf.write_str((self.debug_str)(self.this_arg).into_str())").unwrap();
+ writeln!(w, "\t}}").unwrap();
+ writeln!(w, "}}").unwrap();
+ },
(s, i) => {
if let Some(supertrait) = types.crate_types.traits.get(s) {
- let mut module_iter = s.rsplitn(2, "::");
- module_iter.next().unwrap();
- let supertrait_module = module_iter.next().unwrap();
- let imports = ImportResolver::new(supertrait_module.splitn(2, "::").next().unwrap(), &types.crate_types.lib_ast.dependencies,
- supertrait_module, &types.crate_types.lib_ast.modules.get(supertrait_module).unwrap().items);
- let resolver = TypeResolver::new(&supertrait_module, imports, types.crate_types);
+ let resolver = get_module_type_resolver!(s, types.crate_libs, types.crate_types);
writeln!(w, "impl {} for {} {{", s, trait_name).unwrap();
impl_trait_for_c!(supertrait, format!(".{}", i), &resolver);
writeln!(w, "}}").unwrap();
}
if let Some(ident) = &field.ident {
- let ref_type = syn::Type::Reference(syn::TypeReference {
- and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None,
- elem: Box::new(field.ty.clone()) });
- 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, 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 types.understood_c_type(&field.ty, Some(&gen_types)) {
if types.understood_c_path(&trait_path.1) {
let full_trait_path = types.resolve_path(&trait_path.1, None);
let trait_obj = *types.crate_types.traits.get(&full_trait_path).unwrap();
+
+ let supertrait_name;
+ let supertrait_resolver;
+ walk_supertraits!(trait_obj, Some(&types), (
+ (s, _i) => {
+ if let Some(supertrait) = types.crate_types.traits.get(s) {
+ supertrait_name = s.to_string();
+ supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_libs, types.crate_types);
+ gen_types.learn_associated_types(&supertrait, &supertrait_resolver);
+ break;
+ }
+ }
+ ) );
// We learn the associated types maping from the original trait object.
// That's great, except that they are unresolved idents, so if we learn
// mappings from a trai defined in a different file, we may mis-resolve or
- // fail to resolve the mapped types.
- gen_types.learn_associated_types(trait_obj, types);
+ // fail to resolve the mapped types. Thus, we have to construct a new
+ // resolver for the module that the trait was defined in here first.
+ let trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ gen_types.learn_associated_types(trait_obj, &trait_resolver);
let mut impl_associated_types = HashMap::new();
for item in i.items.iter() {
match item {
},
("Sync", _) => {}, ("Send", _) => {},
("std::marker::Sync", _) => {}, ("std::marker::Send", _) => {},
+ ("core::fmt::Debug", _) => {},
(s, t) => {
if let Some(supertrait_obj) = types.crate_types.traits.get(s) {
writeln!(w, "\t\t{}: crate::{} {{", t, s).unwrap();
projects / ldk-c-bindings / blobdiff