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 = "\nuse std::str::FromStr;\nuse std::ffi::c_void;\nuse core::convert::Infallible;\nuse bitcoin::hashes::Hash;\nuse crate::c_types::*;\n";
// *************************************
// *** Manually-expanded conversions ***
}
} } }
+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.
}
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, $type_resolver));
+ // Note that we do *not* use the method generics when printing "native"
+ // rust parts - if the method is generic, we need to print a generic
+ // method.
write!(w, "\tfn {}", m.sig.ident).unwrap();
- $type_resolver.write_rust_generic_param(w, Some(&meth_gen_types), m.sig.generics.params.iter());
+ $type_resolver.write_rust_generic_param(w, Some(&gen_types), m.sig.generics.params.iter());
write!(w, "(").unwrap();
for inp in m.sig.inputs.iter() {
match inp {
}
_ => unimplemented!(),
}
- $type_resolver.write_rust_type(w, Some(&meth_gen_types), &*arg.ty);
+ $type_resolver.write_rust_type(w, Some(&gen_types), &*arg.ty);
}
}
}
match &m.sig.output {
syn::ReturnType::Type(_, rtype) => {
write!(w, " -> ").unwrap();
- $type_resolver.write_rust_type(w, Some(&meth_gen_types), &*rtype)
+ $type_resolver.write_rust_type(w, Some(&gen_types), &*rtype)
},
_ => {},
}
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 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();