]> git.bitcoin.ninja Git - ldk-c-bindings/commitdiff
Support trait impls on enums
authorMatt Corallo <git@bluematt.me>
Mon, 23 Oct 2023 23:45:03 +0000 (23:45 +0000)
committerMatt Corallo <git@bluematt.me>
Tue, 24 Oct 2023 17:23:22 +0000 (17:23 +0000)
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.

c-bindings-gen/src/main.rs

index 6853534624427a7b0a5fcb8295f8b4999254e672..7d6a452b04a08fe34d8cf53ee1bf001e1f968865 100644 (file)
@@ -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);
 }