Merge pull request #113 from TheBlueMatt/main

Update args on supertraits of supertraits when cloning trait impls

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 7c066875a5b6a0198e8dadf2ecdaa7d6e725831e..22eabf7affbb53fdfb7c47a863fd4db9232e37ed 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/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();

diff --git a/lightning-c-bindings/src/lightning/sign.rs b/lightning-c-bindings/src/lightning/sign.rs
index 33d731669abcc773d499809089c34507d1d21db7..ded52641910faed548eb3b37abb8945397a53d6f 100644 (file)
--- a/lightning-c-bindings/src/lightning/sign.rs
+++ b/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]