X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=a114c2289c921d8156009942485ac453673c8709;hb=f303e5776622e785ae77de1cdf03a788bb98eb57;hp=9cd32feb8f7bfe6d1ebeee93e076cfa25c0bf82f;hpb=29b37069e9deb8c13bfb0e7a51a7886073e822c5;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 9cd32fe..a114c22 100644
--- 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 {