Support trait impls on enums

Previously we'd only generate correct code for trait impls on
structs, but there's no reason for that restriction. Here we also
implement it on enums.

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 6853534624427a7b0a5fcb8295f8b4999254e672..7d6a452b04a08fe34d8cf53ee1bf001e1f968865 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -94,11 +94,15 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
                                writeln!(w, ")").unwrap();
 
                                writeln!(w, "}}").unwrap();
+
+                               writeln!(w, "#[allow(unused)]").unwrap();
+                               writeln!(w, "pub(crate) extern \"C\" fn {}_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {{", for_obj).unwrap();
                                if has_inner {
-                                       writeln!(w, "pub(crate) extern \"C\" fn {}_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {{", for_obj).unwrap();
                                        writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &*(obj as *const native{}) }})", for_obj).unwrap();
-                                       writeln!(w, "}}").unwrap();
+                               } else {
+                                       writeln!(w, "\t{}_write(unsafe {{ &*(obj as *const {}) }})", for_obj, for_obj).unwrap();
                                }
+                               writeln!(w, "}}").unwrap();
                        },
                        "lightning::util::ser::Readable"|"lightning::util::ser::ReadableArgs"|"lightning::util::ser::MaybeReadable" => {
                                // Create the Result<Object, DecodeError> syn::Type
@@ -553,6 +557,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
        writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap();
        writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap();
 
+       writeln!(w, "#[allow(unused)]").unwrap();
        writeln!(w, "pub(crate) fn {}_clone_fields(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap();
        writeln!(w, "\t{} {{", trait_name).unwrap();
        writeln!(w, "\t\tthis_arg: orig.this_arg,").unwrap();
@@ -1022,10 +1027,14 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
                                                if is_type_unconstructable(&resolved_path) {
                                                        writeln!(w, "\t\tunreachable!();").unwrap();
                                                } else {
-                                                       writeln!(w, "\t\tlet mut rust_obj = {} {{ inner: ObjOps::heap_alloc(obj), is_owned: true }};", ident).unwrap();
-                                                       writeln!(w, "\t\tlet mut ret = {}_as_{}(&rust_obj);", ident, trait_obj.ident).unwrap();
-                                                       writeln!(w, "\t\t// We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn").unwrap();
-                                                       writeln!(w, "\t\trust_obj.inner = core::ptr::null_mut();").unwrap();
+                                                       types.write_to_c_conversion_new_var(w, &format_ident!("obj"), &*i.self_ty, Some(&gen_types), false);
+                                                       write!(w, "\t\tlet rust_obj = ").unwrap();
+                                                       types.write_to_c_conversion_inline_prefix(w, &*i.self_ty, Some(&gen_types), false);
+                                                       write!(w, "obj").unwrap();
+                                                       types.write_to_c_conversion_inline_suffix(w, &*i.self_ty, Some(&gen_types), false);
+                                                       writeln!(w, ";\n\t\tlet mut ret = {}_as_{}(&rust_obj);", ident, trait_obj.ident).unwrap();
+                                                       writeln!(w, "\t\t// We want to free rust_obj when ret gets drop()'d, not rust_obj, so forget it and set ret's free() fn").unwrap();
+                                                       writeln!(w, "\t\tcore::mem::forget(rust_obj);").unwrap();
                                                        writeln!(w, "\t\tret.free = Some({}_free_void);", ident).unwrap();
                                                        writeln!(w, "\t\tret").unwrap();
                                                }
@@ -1040,7 +1049,11 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
                                                writeln!(w, "/// This copies the `inner` pointer in this_arg and thus the returned {} must be freed before this_arg is", trait_obj.ident).unwrap();
                                                write!(w, "#[no_mangle]\npub extern \"C\" fn {}_as_{}(this_arg: &{}) -> crate::{} {{\n", ident, trait_obj.ident, ident, full_trait_path).unwrap();
                                                writeln!(w, "\tcrate::{} {{", full_trait_path).unwrap();
-                                               writeln!(w, "\t\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap();
+                                               if types.c_type_has_inner_from_path(&resolved_path) {
+                                                       writeln!(w, "\t\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap();
+                                               } else {
+                                                       writeln!(w, "\t\tthis_arg: unsafe {{ ObjOps::untweak_ptr(this_arg as *const {} as *mut {}) as *mut c_void }},", ident, ident).unwrap();
+                                               }
                                                writeln!(w, "\t\tfree: None,").unwrap();
 
                                                macro_rules! write_meth {
@@ -1344,7 +1357,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
                                                writeln!(w, "#[allow(unused)]").unwrap();
                                                writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap();
                                                writeln!(w, "pub(crate) extern \"C\" fn {}_clone_void(this_ptr: *const c_void) -> *mut c_void {{", ident).unwrap();
-                                               writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *mut native{})).clone() }})) as *mut c_void", ident).unwrap();
+                                               writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *const native{})).clone() }})) as *mut c_void", ident).unwrap();
                                                writeln!(w, "}}").unwrap();
                                                writeln!(w, "#[no_mangle]").unwrap();
                                                writeln!(w, "/// Creates a copy of the {}", ident).unwrap();
@@ -1935,7 +1948,18 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
                writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", e.ident, e.ident, e.ident).unwrap();
                writeln!(w, "\torig.clone()").unwrap();
                writeln!(w, "}}").unwrap();
+               writeln!(w, "#[allow(unused)]").unwrap();
+               writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap();
+               writeln!(w, "pub(crate) extern \"C\" fn {}_clone_void(this_ptr: *const c_void) -> *mut c_void {{", e.ident).unwrap();
+               writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *const {})).clone() }})) as *mut c_void", e.ident).unwrap();
+               writeln!(w, "}}").unwrap();
        }
+
+       writeln!(w, "#[allow(unused)]").unwrap();
+       writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap();
+       writeln!(w, "pub(crate) extern \"C\" fn {}_free_void(this_ptr: *mut c_void) {{", e.ident).unwrap();
+       writeln!(w, "\tlet _ = unsafe {{ Box::from_raw(this_ptr as *mut {}) }};\n}}", e.ident).unwrap();
+
        w.write_all(&constr).unwrap();
        write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free, None);
 }