Merge pull request #113 from TheBlueMatt/main

Update args on supertraits of supertraits when cloning trait impls

c-bindings-gen/src/main.rs

@@ -267,8 +267,8 @@ 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;
+	($type_in_module: expr, $crate_types: expr) => { {
+		let module: &str = &$type_in_module;
 		let mut module_iter = module.rsplitn(2, "::");
 		module_iter.next().unwrap();
 		let module = module_iter.next().unwrap();
@@ -304,7 +304,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) {
 				supertrait_name = s.to_string();
-				supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_libs, types.crate_types);
+				supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_types);
 				gen_types.learn_associated_types(&supertrait, &supertrait_resolver);
 				break;
 			}
@@ -600,10 +600,10 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 		},
 		(s, i, generic_args) => {
 			if let Some(supertrait) = types.crate_types.traits.get(s) {
-				let resolver = get_module_type_resolver!(s, types.crate_libs, types.crate_types);
+				let resolver = get_module_type_resolver!(s, types.crate_types);
 				macro_rules! impl_supertrait {
 					($s: expr, $supertrait: expr, $i: expr, $generic_args: expr) => {
-						let resolver = get_module_type_resolver!($s, types.crate_libs, types.crate_types);
+						let resolver = get_module_type_resolver!($s, types.crate_types);
 
 						// Blindly assume that the same imports where `supertrait` is defined are also
 						// imported here. This will almost certainly break at some point, but it should be
@@ -971,7 +971,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
 							(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);
+									supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_types);
 									gen_types.learn_associated_types(&supertrait, &supertrait_resolver);
 									break;
 								}
@@ -982,7 +982,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
 						// mappings from a trai defined in a different file, we may mis-resolve or
 						// 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 mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+						let mut trait_resolver = get_module_type_resolver!(full_trait_path, 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() {
@@ -1115,7 +1115,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
 									}
 									write_impl_fields!(s, supertrait_obj, t, "\t", types);
 
-									let resolver = get_module_type_resolver!(s, types.crate_libs, types.crate_types);
+									let resolver = get_module_type_resolver!(s, types.crate_types);
 									walk_supertraits!(supertrait_obj, Some(&resolver), (
 										(s, t, _) => {
 											if let Some(supertrait_obj) = types.crate_types.traits.get(s) {
@@ -1254,15 +1254,22 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
 							writeln!(w, "extern \"C\" fn {}_{}_cloned(new_obj: &mut crate::{}) {{", trait_obj.ident, ident, full_trait_path).unwrap();
 							writeln!(w, "\tnew_obj.this_arg = {}_clone_void(new_obj.this_arg);", ident).unwrap();
 							writeln!(w, "\tnew_obj.free = Some({}_free_void);", ident).unwrap();
-							walk_supertraits!(trait_obj, Some(&types), (
-								(s, t, _) => {
-									if types.crate_types.traits.get(s).is_some() {
-										assert!(!types.is_clonable(s)); // We don't currently support cloning with a clonable supertrait
-										writeln!(w, "\tnew_obj.{}.this_arg = new_obj.this_arg;", t).unwrap();
-										writeln!(w, "\tnew_obj.{}.free = None;", t).unwrap();
+
+							fn seek_supertraits<W: std::io::Write>(w: &mut W, pfx: &str, tr: &syn::ItemTrait, types: &TypeResolver) {
+								walk_supertraits!(tr, Some(types), (
+									(s, t, _) => {
+										if types.crate_types.traits.get(s).is_some() {
+											assert!(!types.is_clonable(s)); // We don't currently support cloning with a clonable supertrait
+											writeln!(w, "\tnew_obj.{}{}.this_arg = new_obj.this_arg;", pfx, t).unwrap();
+											writeln!(w, "\tnew_obj.{}{}.free = None;", pfx, t).unwrap();
+											let tr = types.crate_types.traits.get(s).unwrap();
+											let resolver = get_module_type_resolver!(s, types.crate_types);
+											seek_supertraits(w, &format!("{}.", t), tr, &resolver);
+										}
 									}
-								}
-							) );
+								) );
+							}
+							seek_supertraits(w, "", trait_obj, types);
 							writeln!(w, "}}").unwrap();
 						}
 						write!(w, "\n").unwrap();

lightning-c-bindings/src/lightning/sign.rs

@@ -2188,6 +2188,8 @@ extern "C" fn WriteableEcdsaChannelSigner_InMemorySigner_cloned(new_obj: &mut cr
 	new_obj.free = Some(InMemorySigner_free_void);
 	new_obj.EcdsaChannelSigner.this_arg = new_obj.this_arg;
 	new_obj.EcdsaChannelSigner.free = None;
+	new_obj.EcdsaChannelSigner.ChannelSigner.this_arg = new_obj.this_arg;
+	new_obj.EcdsaChannelSigner.ChannelSigner.free = None;
 }
 
 #[no_mangle]