Learn supertrait associated types when processing traits

[ldk-c-bindings] / c-bindings-gen / src / main.rs

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 9cd32feb8f7bfe6d1ebeee93e076cfa25c0bf82f..a114c2289c921d8156009942485ac453673c8709 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -212,6 +212,18 @@ macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $($pat: pat)|* => $
        }
 } } }
 
+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.
@@ -229,6 +241,22 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
        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);
 
@@ -510,12 +538,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
                },
                (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();
@@ -750,11 +773,26 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
                                        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 {