X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=1572b313582db2e2275b23b99ca3ba77a900b3cb;hb=bf77ececa4ed93dd954c13d59ad2c14f10710586;hp=5bc27eb9b7317301d2bf0151854a2a50ab613d2e;hpb=5186f42ac18f2ef123eb2e5109c9e4af3d3e03fc;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 5bc27eb..1572b31 100644
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -241,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);
 
@@ -386,8 +402,11 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 						}
 						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 {
@@ -415,7 +434,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 										}
 										_ => unimplemented!(),
 									}
-									$type_resolver.write_rust_type(w, Some(&meth_gen_types), &*arg.ty);
+									$type_resolver.write_rust_type(w, Some(&gen_types), &*arg.ty);
 								}
 							}
 						}
@@ -423,7 +442,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, 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)
 							},
 							_ => {},
 						}
@@ -757,11 +776,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 {