Expose struct method calls on trait structs to C++ directly

We can add method calls for non-trait structs later, but this is
particularly useful as otherwise you need to extract both the
method and the `this_arg` to make the call.

diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs
index 82b10ad831bd4ca2ef21ec3c1d9804d5dbe6e26c..643a8be7c3c1fdb5052dde93872d3b14456c3e95 100644 (file)
--- a/c-bindings-gen/src/blocks.rs
+++ b/c-bindings-gen/src/blocks.rs
@@ -20,7 +20,7 @@ use crate::types::*;
 /// Writes out a C++ wrapper class for the given type, which contains various utilities to access
 /// the underlying C-mapped type safely avoiding some common memory management issues by handling
 /// resource-freeing and prevending accidental raw copies.
-pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: bool) {
+pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: bool, trait_methods: Option<Vec<(String, String)>>) {
        writeln!(cpp_header_file, "class {} {{", ty).unwrap();
        writeln!(cpp_header_file, "private:").unwrap();
        writeln!(cpp_header_file, "\tLDK{} self;", ty).unwrap();
@@ -39,6 +39,14 @@ pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: b
        writeln!(cpp_header_file, "\tLDK{}* operator ->() {{ return &self; }}", ty).unwrap();
        writeln!(cpp_header_file, "\tconst LDK{}* operator &() const {{ return &self; }}", ty).unwrap();
        writeln!(cpp_header_file, "\tconst LDK{}* operator ->() const {{ return &self; }}", ty).unwrap();
+       if let Some(methods) = trait_methods {
+               for (meth_name, meth_docs) in methods {
+                       cpp_header_file.write_all(meth_docs.as_bytes()).unwrap();
+                       // Note that we have zero logic to print C/C__ code for a given function. Instead, we
+                       // simply use sed to replace the following in genbindings.sh
+                       writeln!(cpp_header_file, "XXX {} {}", ty, meth_name).unwrap();
+               }
+       }
        writeln!(cpp_header_file, "}};").unwrap();
 }
 

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 4c14074143966fe89b0f54c6979c5889ca4e87dc..c8adf7df1b6e7238c0a907c8aa4662019dc3b70b 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -237,7 +237,9 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
        writeln!(w, "\t/// An opaque pointer which is passed to your function implementations as an argument.").unwrap();
        writeln!(w, "\t/// This has no meaning in the LDK, and can be NULL or any other value.").unwrap();
        writeln!(w, "\tpub this_arg: *mut c_void,").unwrap();
-       let mut generated_fields = Vec::new(); // Every field's (name, Option<clone_fn>) except this_arg, used in Clone generation
+       // We store every field's (name, Option<clone_fn>, docs) except this_arg, used in Clone generation
+       // docs is only set if its a function which should be callable on the object itself in C++
+       let mut generated_fields = Vec::new();
        for item in t.items.iter() {
                match item {
                        &syn::TraitItem::Method(ref m) => {
@@ -271,14 +273,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
                                                // happen) as well as provide an Option<>al function pointer which is
                                                // called when the trait method is called which allows updating on the fly.
                                                write!(w, "\tpub {}: ", m.sig.ident).unwrap();
-                                               generated_fields.push((format!("{}", m.sig.ident), None));
+                                               generated_fields.push((format!("{}", m.sig.ident), None, None));
                                                types.write_c_type(w, &*r.elem, Some(&meth_gen_types), false);
                                                writeln!(w, ",").unwrap();
                                                writeln!(w, "\t/// Fill in the {} field as a reference to it will be given to Rust after this returns", m.sig.ident).unwrap();
                                                writeln!(w, "\t/// Note that this takes a pointer to this object, not the this_ptr like other methods do").unwrap();
                                                writeln!(w, "\t/// This function pointer may be NULL if {} is filled in when this object is created and never needs updating.", m.sig.ident).unwrap();
                                                writeln!(w, "\tpub set_{}: Option<extern \"C\" fn(&{})>,", m.sig.ident, trait_name).unwrap();
-                                               generated_fields.push((format!("set_{}", m.sig.ident), None));
+                                               generated_fields.push((format!("set_{}", m.sig.ident), None, None));
                                                // Note that cbindgen will now generate
                                                // typedef struct Thing {..., set_thing: (const struct Thing*), ...} Thing;
                                                // which does not compile since Thing is not defined before it is used.
@@ -290,8 +292,12 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
                                        writeln!(w, "\t#[must_use]").unwrap();
                                }
 
+                               let mut cpp_docs = Vec::new();
+                               writeln_docs(&mut cpp_docs, &m.attrs, "\t * ");
+                               let docs_string = "\t/**\n".to_owned() + &String::from_utf8(cpp_docs).unwrap().replace("///", "") + "\t */\n";
+
                                write!(w, "\tpub {}: extern \"C\" fn (", m.sig.ident).unwrap();
-                               generated_fields.push((format!("{}", m.sig.ident), None));
+                               generated_fields.push((format!("{}", m.sig.ident), None, Some(docs_string)));
                                write_method_params(w, &m.sig, "c_void", types, Some(&meth_gen_types), true, false);
                                writeln!(w, ",").unwrap();
                        },
@@ -306,26 +312,32 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
                        writeln!(w, "\t/// The new {} is provided, and should be mutated as needed to perform a", trait_name).unwrap();
                        writeln!(w, "\t/// deep copy of the object pointed to by this_arg or avoid any double-freeing.").unwrap();
                        writeln!(w, "\tpub cloned: Option<extern \"C\" fn (new_{}: &mut {})>,", trait_name, trait_name).unwrap();
-                       generated_fields.push(("cloned".to_owned(), None));
+                       generated_fields.push(("cloned".to_owned(), None, None));
                },
                ("std::cmp::Eq", _)|("core::cmp::Eq", _) => {
-                       writeln!(w, "\t/// Checks if two objects are equal given this object's this_arg pointer and another object.").unwrap();
+                       let eq_docs = "Checks if two objects are equal given this object's this_arg pointer and another object.";
+                       writeln!(w, "\t/// {}", eq_docs).unwrap();
                        writeln!(w, "\tpub eq: extern \"C\" fn (this_arg: *const c_void, other_arg: &{}) -> bool,", trait_name).unwrap();
-                       generated_fields.push(("eq".to_owned(), None));
+                       generated_fields.push(("eq".to_owned(), None, Some(format!("\t/** {} */\n", eq_docs))));
                },
                ("std::hash::Hash", _)|("core::hash::Hash", _) => {
-                       writeln!(w, "\t/// Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.").unwrap();
-                       writeln!(w, "\t/// This is used, for example, for inclusion of this object in a hash map.").unwrap();
+                       let hash_docs_a = "Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.";
+                       let hash_docs_b = "This is used, for example, for inclusion of this object in a hash map.";
+                       writeln!(w, "\t/// {}", hash_docs_a).unwrap();
+                       writeln!(w, "\t/// {}", hash_docs_b).unwrap();
                        writeln!(w, "\tpub hash: extern \"C\" fn (this_arg: *const c_void) -> u64,").unwrap();
-                       generated_fields.push(("hash".to_owned(), None));
+                       generated_fields.push(("hash".to_owned(), None,
+                               Some(format!("\t/**\n\t * {}\n\t * {}\n\t */\n", hash_docs_a, hash_docs_b))));
                },
                ("Send", _) => {}, ("Sync", _) => {},
                (s, i) => {
+                       // TODO: Both of the below should expose supertrait methods in C++, but doing so is
+                       // nontrivial.
                        generated_fields.push(if types.crate_types.traits.get(s).is_none() {
                                let (docs, name, ret) = convert_trait_impl_field(s);
                                writeln!(w, "\t/// {}", docs).unwrap();
                                writeln!(w, "\tpub {}: extern \"C\" fn (this_arg: *const c_void) -> {},", name, ret).unwrap();
-                               (name, None) // Assume clonable
+                               (name, None, None) // Assume clonable
                        } else {
                                // For in-crate supertraits, just store a C-mapped copy of the supertrait as a member.
                                writeln!(w, "\t/// Implementation of {} for this object.", i).unwrap();
@@ -333,14 +345,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
                                writeln!(w, "\tpub {}: crate::{},", i, s).unwrap();
                                (format!("{}", i), if !is_clonable {
                                        Some(format!("crate::{}_clone_fields", s))
-                               } else { None })
+                               } else { None }, None)
                        });
                }
        ) );
        writeln!(w, "\t/// Frees any resources associated with this object given its this_arg pointer.").unwrap();
        writeln!(w, "\t/// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.").unwrap();
        writeln!(w, "\tpub free: Option<extern \"C\" fn(this_arg: *mut c_void)>,").unwrap();
-       generated_fields.push(("free".to_owned(), None));
+       generated_fields.push(("free".to_owned(), None, None));
        writeln!(w, "}}").unwrap();
 
        macro_rules! impl_trait_for_c {
@@ -449,7 +461,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
        writeln!(w, "pub(crate) extern \"C\" 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();
-       for (field, clone_fn) in generated_fields.iter() {
+       for (field, clone_fn, _) in generated_fields.iter() {
                if let Some(f) = clone_fn {
                        // If the field isn't clonable, blindly assume its a trait and hope for the best.
                        writeln!(w, "\t\t{}: {}(&orig.{}),", field, f, field).unwrap();
@@ -522,7 +534,8 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
        writeln!(w, "\t\t\tf(self.this_arg);").unwrap();
        writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
 
-       write_cpp_wrapper(cpp_headers, &trait_name, true);
+       write_cpp_wrapper(cpp_headers, &trait_name, true, Some(generated_fields.drain(..)
+               .filter_map(|(name, _, docs)| if let Some(docs) = docs { Some((name, docs)) } else { None }).collect()));
 }
 
 /// Write out a simple "opaque" type (eg structs) which contain a pointer to the native Rust type
@@ -567,7 +580,7 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
        writeln!(w, "\t\tret").unwrap();
        writeln!(w, "\t}}\n}}").unwrap();
 
-       write_cpp_wrapper(cpp_headers, &format!("{}", ident), true);
+       write_cpp_wrapper(cpp_headers, &format!("{}", ident), true, None);
 }
 
 /// Writes out all the relevant mappings for a Rust struct, deferring to writeln_opaque to generate
@@ -1360,7 +1373,7 @@ 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();
-       write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free);
+       write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free, None);
 }
 
 fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: &mut TypeResolver<'b, 'a>) {
@@ -1744,7 +1757,7 @@ fn main() {
        // For container templates which we created while walking the crate, make sure we add C++
        // mapped types so that C++ users can utilize the auto-destructors available.
        for (ty, has_destructor) in libtypes.templates_defined.borrow().iter() {
-               write_cpp_wrapper(&mut cpp_header_file, ty, *has_destructor);
+               write_cpp_wrapper(&mut cpp_header_file, ty, *has_destructor, None);
        }
        writeln!(cpp_header_file, "}}").unwrap();
 

diff --git a/genbindings.sh b/genbindings.sh
index 7afc274efb2a21da6099b15b44f3368bfd452a4f..c1bfc8dde3cc6b993c7ba1de73f0cd0af7bf8074 100755 (executable)
--- a/genbindings.sh
+++ b/genbindings.sh
@@ -207,6 +207,70 @@ else
        sed -i 's/#include <stdlib.h>/#include "ldk_rust_types.h"/g' include/lightning.h
 fi
 
+# Build C++ class methods which call trait methods
+set +x # Echoing every command is very verbose here
+OLD_IFS="$IFS"
+export IFS=''
+echo '#include <string.h>' > include/lightningpp_new.hpp
+echo 'namespace LDK {' >> include/lightningpp_new.hpp
+echo '// Forward declarations' >> include/lightningpp_new.hpp
+cat include/lightningpp.hpp | sed -n 's/class \(.*\) {/class \1;/p' >> include/lightningpp_new.hpp
+echo '' >> include/lightningpp_new.hpp
+
+DECLS=""
+while read LINE; do
+       case "$LINE" in
+               "#include <string.h>")
+                       # We already printed this above.
+                       ;;
+               "namespace LDK {")
+                       # We already printed this above.
+                       ;;
+               "}")
+                       # We'll print this at the end
+                       ;;
+               "XXX"*)
+                       STRUCT_NAME="$(echo "$LINE" | awk '{ print $2 }')"
+                       METHOD_NAME="$(echo "$LINE" | awk '{ print $3 }')"
+                       STRUCT_CONTENTS="$(cat include/lightning.h  | sed -n -e "/struct LDK$STRUCT_NAME/{:s" -e "/\} LDK$STRUCT_NAME;/!{N" -e "b s" -e "}" -e p -e "}")"
+                       METHOD="$(echo "$STRUCT_CONTENTS" | grep "(\*$METHOD_NAME)")"
+                       if [ "$METHOD" = "" ]; then
+                               echo "Unable to find method declaration for $LINE"
+                               exit 1
+                       fi
+                       RETVAL="$(echo "$METHOD" | sed 's/[ ]*\([A-Za-z0-9 _]*\)(\*\(.*\)).*/\1/' | sed 's/^struct LDK/LDK::/g' | tr -d ' ')"
+                       [ "$RETVAL" = "LDK::SecretKey" ] && RETVAL="LDKSecretKey"
+                       [ "$RETVAL" = "LDK::PublicKey" ] && RETVAL="LDKPublicKey"
+                       [ "$RETVAL" = "LDK::ThirtyTwoBytes" ] && RETVAL="LDKThirtyTwoBytes"
+                       PARAMS="$(echo "$METHOD" | sed 's/.*(\*.*)(\(const \)*void \*this_arg\(, \)*\(.*\));/\3/')"
+
+                       echo -e "\tinline $RETVAL $METHOD_NAME($PARAMS);" >> include/lightningpp_new.hpp
+                       DECLS="$DECLS"$'\n'"inline $RETVAL $STRUCT_NAME::$METHOD_NAME($PARAMS) {"
+
+                       DECLS="$DECLS"$'\n'$'\t'
+                       [ "$RETVAL" != "void" ] && DECLS="$DECLS$RETVAL ret = "
+                       DECLS="$DECLS(self.$METHOD_NAME)(self.this_arg"
+
+                       IFS=','; for PARAM in $PARAMS; do
+                               DECLS="$DECLS, "
+                               DECLS="$DECLS$(echo $PARAM | sed 's/.* (*\**\([a-zA-Z0-9_]*\)\()[\[0-9\]*]\)*/\1/')"
+                       done
+                       IFS=''
+
+                       DECLS="$DECLS);"
+                       [ "$RETVAL" != "void" ] && DECLS="$DECLS"$'\n'$'\t'"return ret;"
+                       DECLS="$DECLS"$'\n'"}"
+                       ;;
+               *)
+                       echo "$LINE" >> include/lightningpp_new.hpp
+       esac
+done < include/lightningpp.hpp
+echo "$DECLS" >> include/lightningpp_new.hpp
+echo "}" >> include/lightningpp_new.hpp
+export IFS="$OLD_IFS"
+set -x
+mv include/lightningpp_new.hpp include/lightningpp.hpp
+
 # Finally, sanity-check the generated C and C++ bindings with demo apps:
 # Naively run the C demo app:
 gcc $LOCAL_CFLAGS -Wall -g -pthread demo.c target/debug/libldk.a -ldl