[bindings] Concretize Result types without type aliasing

While the type aliasing trick works great for cbindgen,
wasm_bindgen doesn't support it and requires fully-concrete types.
In order to better support wasm_bindgen in the future, we do so
here, adding a function which manually writes out almost the exact
thing which was templated previously in concrete form.

As a nice side-effect, we no longer have to allocate and free a u8
for generic parameters which were `()` (though we still do in some
conversion functions, which we can get rid of when we similarly
concretize all generics fully).

diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs
index 107c72b3db4b97a852cd0c1a84c8b17ed8d92d7d..07482c4b4ad1c0b3174d9f9363c4ef417eaac6ae 100644 (file)
--- a/c-bindings-gen/src/blocks.rs
+++ b/c-bindings-gen/src/blocks.rs
@@ -32,6 +32,120 @@ pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: b
        writeln!(cpp_header_file, "}};").unwrap();
 }
 
+/// Writes out a C-callable concrete Result<A, B> struct and utility methods
+pub fn write_result_block<W: std::io::Write>(w: &mut W, mangled_container: &str, ok_type: &str, err_type: &str) {
+       writeln!(w, "#[repr(C)]").unwrap();
+       writeln!(w, "pub union {}Ptr {{", mangled_container).unwrap();
+       if ok_type != "()" {
+               writeln!(w, "\tpub result: *mut {},", ok_type).unwrap();
+       } else {
+               writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the OK variant").unwrap();
+               writeln!(w, "\tpub result: *mut std::ffi::c_void,").unwrap();
+       }
+       if err_type != "()" {
+               writeln!(w, "\tpub err: *mut {},", err_type).unwrap();
+       } else {
+               writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the Err variant").unwrap();
+               writeln!(w, "\tpub err: *mut std::ffi::c_void,").unwrap();
+       }
+       writeln!(w, "}}").unwrap();
+       writeln!(w, "#[repr(C)]").unwrap();
+       writeln!(w, "pub struct {} {{", mangled_container).unwrap();
+       writeln!(w, "\tpub contents: {}Ptr,", mangled_container).unwrap();
+       writeln!(w, "\tpub result_ok: bool,").unwrap();
+       writeln!(w, "}}").unwrap();
+
+       writeln!(w, "#[no_mangle]").unwrap();
+       if ok_type != "()" {
+               writeln!(w, "pub extern \"C\" fn {}_ok(o: {}) -> {} {{", mangled_container, ok_type, mangled_container).unwrap();
+       } else {
+               writeln!(w, "pub extern \"C\" fn {}_ok() -> {} {{", mangled_container, mangled_container).unwrap();
+       }
+       writeln!(w, "\t{} {{", mangled_container).unwrap();
+       writeln!(w, "\t\tcontents: {}Ptr {{", mangled_container).unwrap();
+       if ok_type != "()" {
+               writeln!(w, "\t\t\tresult: Box::into_raw(Box::new(o)),").unwrap();
+       } else {
+               writeln!(w, "\t\t\tresult: std::ptr::null_mut(),").unwrap();
+       }
+       writeln!(w, "\t\t}},").unwrap();
+       writeln!(w, "\t\tresult_ok: true,").unwrap();
+       writeln!(w, "\t}}").unwrap();
+       writeln!(w, "}}").unwrap();
+
+       writeln!(w, "#[no_mangle]").unwrap();
+       if err_type != "()" {
+               writeln!(w, "pub extern \"C\" fn {}_err(e: {}) -> {} {{", mangled_container, err_type, mangled_container).unwrap();
+       } else {
+               writeln!(w, "pub extern \"C\" fn {}_err() -> {} {{", mangled_container, mangled_container).unwrap();
+       }
+       writeln!(w, "\t{} {{", mangled_container).unwrap();
+       writeln!(w, "\t\tcontents: {}Ptr {{", mangled_container).unwrap();
+       if err_type != "()" {
+               writeln!(w, "\t\t\terr: Box::into_raw(Box::new(e)),").unwrap();
+       } else {
+               writeln!(w, "\t\t\terr: std::ptr::null_mut(),").unwrap();
+       }
+       writeln!(w, "\t\t}},").unwrap();
+       writeln!(w, "\t\tresult_ok: false,").unwrap();
+       writeln!(w, "\t}}").unwrap();
+       writeln!(w, "}}").unwrap();
+
+       writeln!(w, "#[no_mangle]").unwrap();
+       writeln!(w, "pub extern \"C\" fn {}_free(_res: {}) {{ }}", mangled_container, mangled_container).unwrap();
+       writeln!(w, "impl Drop for {} {{", mangled_container).unwrap();
+       writeln!(w, "\tfn drop(&mut self) {{").unwrap();
+       writeln!(w, "\t\tif self.result_ok {{").unwrap();
+       if ok_type != "()" {
+               writeln!(w, "\t\t\tif unsafe {{ !(self.contents.result as *mut ()).is_null() }} {{").unwrap();
+               writeln!(w, "\t\t\t\tlet _ = unsafe {{ Box::from_raw(self.contents.result) }};").unwrap();
+               writeln!(w, "\t\t\t}}").unwrap();
+       }
+       writeln!(w, "\t\t}} else {{").unwrap();
+       if err_type != "()" {
+               writeln!(w, "\t\t\tif unsafe {{ !(self.contents.err as *mut ()).is_null() }} {{").unwrap();
+               writeln!(w, "\t\t\t\tlet _ = unsafe {{ Box::from_raw(self.contents.err) }};").unwrap();
+               writeln!(w, "\t\t\t}}").unwrap();
+       }
+       writeln!(w, "\t\t}}").unwrap();
+       writeln!(w, "\t}}").unwrap();
+       writeln!(w, "}}").unwrap();
+
+       // TODO: Templates should use () now that they can, too
+       let templ_ok_type = if ok_type != "()" { ok_type } else { "u8" };
+       let templ_err_type = if err_type != "()" { err_type } else { "u8" };
+
+       writeln!(w, "impl From<crate::c_types::CResultTempl<{}, {}>> for {} {{", templ_ok_type, templ_err_type, mangled_container).unwrap();
+       writeln!(w, "\tfn from(mut o: crate::c_types::CResultTempl<{}, {}>) -> Self {{", templ_ok_type, templ_err_type).unwrap();
+       writeln!(w, "\t\tlet contents = if o.result_ok {{").unwrap();
+       if ok_type != "()" {
+               writeln!(w, "\t\t\tlet result = unsafe {{ o.contents.result }};").unwrap();
+               writeln!(w, "\t\t\tunsafe {{ o.contents.result = std::ptr::null_mut() }};").unwrap();
+               writeln!(w, "\t\t\t{}Ptr {{ result }}", mangled_container).unwrap();
+       } else {
+               writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.result) }};").unwrap();
+               writeln!(w, "\t\t\to.contents.result = std::ptr::null_mut();").unwrap();
+               writeln!(w, "\t\t\t{}Ptr {{ result: std::ptr::null_mut() }}", mangled_container).unwrap();
+       }
+       writeln!(w, "\t\t}} else {{").unwrap();
+       if err_type != "()" {
+               writeln!(w, "\t\t\tlet err = unsafe {{ o.contents.err }};").unwrap();
+               writeln!(w, "\t\t\tunsafe {{ o.contents.err = std::ptr::null_mut(); }}").unwrap();
+               writeln!(w, "\t\t\t{}Ptr {{ err }}", mangled_container).unwrap();
+       } else {
+               writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.err) }};").unwrap();
+               writeln!(w, "\t\t\to.contents.err = std::ptr::null_mut();").unwrap();
+               writeln!(w, "\t\t\t{}Ptr {{ err: std::ptr::null_mut() }}", mangled_container).unwrap();
+       }
+       writeln!(w, "\t\t}};").unwrap();
+       writeln!(w, "\t\tSelf {{").unwrap();
+       writeln!(w, "\t\t\tcontents,").unwrap();
+       writeln!(w, "\t\t\tresult_ok: o.result_ok,").unwrap();
+       writeln!(w, "\t\t}}").unwrap();
+       writeln!(w, "\t}}").unwrap();
+       writeln!(w, "}}").unwrap();
+}
+
 /// Prints the docs from a given attribute list unless its tagged no export
 pub fn writeln_docs<W: std::io::Write>(w: &mut W, attrs: &[syn::Attribute], prefix: &str) {
        for attr in attrs.iter() {

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index d6a2c989e1ab21694882fd0c713d311f655800c4..59cc51fef40c6053d8bbb6608b805b57681c4e1a 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -3,6 +3,8 @@ use std::fs::File;
 use std::io::Write;
 use std::hash;
 
+use crate::blocks::*;
+
 use proc_macro2::{TokenTree, Span};
 
 // The following utils are used purely to build our known types maps - they break down all the
@@ -745,8 +747,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        "Result" if !is_ref => {
                                Some(("match ",
                                                vec![(" { Ok(mut o) => crate::c_types::CResultTempl::ok(".to_string(), "o".to_string()),
-                                                       ("), Err(mut e) => crate::c_types::CResultTempl::err(".to_string(), "e".to_string())],
-                                               ") }"))
+                                                       (").into(), Err(mut e) => crate::c_types::CResultTempl::err(".to_string(), "e".to_string())],
+                                               ").into() }"))
                        },
                        "Vec" if !is_ref => {
                                Some(("Vec::new(); for item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }"))
@@ -1713,43 +1715,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
        // ******************************************************
 
        fn write_template_constructor<W: std::io::Write>(&mut self, w: &mut W, container_type: &str, mangled_container: &str, args: &Vec<&syn::Type>, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
-               if container_type == "Result" {
-                       assert_eq!(args.len(), 2);
-                       macro_rules! write_fn {
-                               ($call: expr) => { {
-                                       writeln!(w, "#[no_mangle]\npub extern \"C\" fn {}_{}() -> {} {{", mangled_container, $call, mangled_container).unwrap();
-                                       writeln!(w, "\t{}::CResultTempl::{}(0)\n}}\n", Self::container_templ_path(), $call).unwrap();
-                               } }
-                       }
-                       macro_rules! write_alias {
-                               ($call: expr, $item: expr) => { {
-                                       write!(w, "#[no_mangle]\npub static {}_{}: extern \"C\" fn (", mangled_container, $call).unwrap();
-                                       if let syn::Type::Path(syn::TypePath { path, .. }) = $item {
-                                               let resolved = self.resolve_path(path, generics);
-                                               if self.is_known_container(&resolved, is_ref) || self.is_transparent_container(&resolved, is_ref) {
-                                                       self.write_c_mangled_container_path_intern(w, Self::path_to_generic_args(path), generics,
-                                                               &format!("{}", single_ident_generic_path_to_ident(path).unwrap()), is_ref, false, false, false);
-                                               } else {
-                                                       self.write_template_generics(w, &mut [$item].iter().map(|t| *t), generics, is_ref, true);
-                                               }
-                                       } else if let syn::Type::Tuple(syn::TypeTuple { elems, .. }) = $item {
-                                               self.write_c_mangled_container_path_intern(w, elems.iter().collect(), generics,
-                                                       &format!("{}Tuple", elems.len()), is_ref, false, false, false);
-                                       } else { unimplemented!(); }
-                                       write!(w, ") -> {} =\n\t{}::CResultTempl::<", mangled_container, Self::container_templ_path()).unwrap();
-                                       self.write_template_generics(w, &mut args.iter().map(|t| *t), generics, is_ref, true);
-                                       writeln!(w, ">::{};\n", $call).unwrap();
-                               } }
-                       }
-                       match args[0] {
-                               syn::Type::Tuple(t) if t.elems.is_empty() => write_fn!("ok"),
-                               _ => write_alias!("ok", args[0]),
-                       }
-                       match args[1] {
-                               syn::Type::Tuple(t) if t.elems.is_empty() => write_fn!("err"),
-                               _ => write_alias!("err", args[1]),
-                       }
-               } else if container_type.ends_with("Tuple") {
+               if container_type.ends_with("Tuple") {
                        write!(w, "#[no_mangle]\npub extern \"C\" fn {}_new(", mangled_container).unwrap();
                        for (idx, gen) in args.iter().enumerate() {
                                write!(w, "{}{}: ", if idx != 0 { ", " } else { "" }, ('a' as u8 + idx as u8) as char).unwrap();
@@ -1767,7 +1733,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                true
        }
 
-       fn write_template_generics<'b, W: std::io::Write>(&self, w: &mut W, args: &mut dyn Iterator<Item=&'b syn::Type>, generics: Option<&GenericTypes>, is_ref: bool, in_crate: bool) {
+       fn write_template_generics<'b, W: std::io::Write>(&mut self, w: &mut W, args: &mut dyn Iterator<Item=&'b syn::Type>, generics: Option<&GenericTypes>, is_ref: bool, in_crate: bool) {
                for (idx, t) in args.enumerate() {
                        if idx != 0 {
                                write!(w, ", ").unwrap();
@@ -1786,14 +1752,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        write!(w, "{}", resolved_generic).unwrap();
                                } else if let Some(c_type) = self.c_type_from_path(&resolved_generic, is_ref, false) {
                                        if self.is_known_container(&resolved_generic, is_ref) {
+                                               if resolved_generic == "Result" {
+                                                       let mut inner_args = Vec::new();
+                                                       if let syn::PathArguments::AngleBracketed(args) = &p_arg.path.segments.iter().next().unwrap().arguments {
+                                                               for arg in args.args.iter() {
+                                                                       if let syn::GenericArgument::Type(t) = arg { inner_args.push(t) } else { unimplemented!() };
+                                                               }
+                                                       } else { unimplemented!(); }
+                                                       self.write_c_mangled_container_path(w, inner_args, generics, &resolved_generic, is_ref, false, false);
+                                               } else {
                                                        write!(w, "{}::C{}Templ<", Self::container_templ_path(), single_ident_generic_path_to_ident(&p_arg.path).unwrap()).unwrap();
-                                               assert_eq!(p_arg.path.segments.len(), 1);
-                                               if let syn::PathArguments::AngleBracketed(args) = &p_arg.path.segments.iter().next().unwrap().arguments {
-                                                       self.write_template_generics(w, &mut args.args.iter().map(|gen|
-                                                               if let syn::GenericArgument::Type(t) = gen { t } else { unimplemented!() }),
-                                                               generics, is_ref, in_crate);
-                                               } else { unimplemented!(); }
-                                               write!(w, ">").unwrap();
+                                                       assert_eq!(p_arg.path.segments.len(), 1);
+                                                       if let syn::PathArguments::AngleBracketed(args) = &p_arg.path.segments.iter().next().unwrap().arguments {
+                                                               self.write_template_generics(w, &mut args.args.iter().map(|gen|
+                                                                       if let syn::GenericArgument::Type(t) = gen { t } else { unimplemented!() }),
+                                                                       generics, is_ref, in_crate);
+                                                       } else { unimplemented!(); }
+                                                       write!(w, ">").unwrap();
+                                               }
                                        } else if resolved_generic == "Option" {
                                                if let syn::PathArguments::AngleBracketed(args) = &p_arg.path.segments.iter().next().unwrap().arguments {
                                                        self.write_template_generics(w, &mut args.args.iter().map(|gen|
@@ -1847,18 +1823,44 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                if !self.crate_types.templates_defined.get(&mangled_container).is_some() {
                        let mut created_container: Vec<u8> = Vec::new();
 
-                       write!(&mut created_container, "pub type {} = ", mangled_container).unwrap();
-                       write!(&mut created_container, "{}::C{}Templ<", Self::container_templ_path(), container_type).unwrap();
-                       self.write_template_generics(&mut created_container, &mut args.iter().map(|t| *t), generics, is_ref, true);
-                       writeln!(&mut created_container, ">;").unwrap();
+                       if container_type == "Result" {
+                               let mut a_ty: Vec<u8> = Vec::new();
+                               if let syn::Type::Tuple(tup) = args.iter().next().unwrap() {
+                                       if tup.elems.is_empty() {
+                                               write!(&mut a_ty, "()").unwrap();
+                                       } else {
+                                               self.write_template_generics(&mut a_ty, &mut args.iter().map(|t| *t).take(1), generics, is_ref, true);
+                                       }
+                               } else {
+                                       self.write_template_generics(&mut a_ty, &mut args.iter().map(|t| *t).take(1), generics, is_ref, true);
+                               }
 
-                       write!(&mut created_container, "#[no_mangle]\npub static {}_free: extern \"C\" fn({}) = ", mangled_container, mangled_container).unwrap();
-                       write!(&mut created_container, "{}::C{}Templ_free::<", Self::container_templ_path(), container_type).unwrap();
-                       self.write_template_generics(&mut created_container, &mut args.iter().map(|t| *t), generics, is_ref, true);
-                       writeln!(&mut created_container, ">;").unwrap();
+                               let mut b_ty: Vec<u8> = Vec::new();
+                               if let syn::Type::Tuple(tup) = args.iter().skip(1).next().unwrap() {
+                                       if tup.elems.is_empty() {
+                                               write!(&mut b_ty, "()").unwrap();
+                                       } else {
+                                               self.write_template_generics(&mut b_ty, &mut args.iter().map(|t| *t).skip(1), generics, is_ref, true);
+                                       }
+                               } else {
+                                       self.write_template_generics(&mut b_ty, &mut args.iter().map(|t| *t).skip(1), generics, is_ref, true);
+                               }
+
+                               write_result_block(&mut created_container, &mangled_container, &String::from_utf8(a_ty).unwrap(), &String::from_utf8(b_ty).unwrap());
+                       } else {
+                               write!(&mut created_container, "pub type {} = ", mangled_container).unwrap();
+                               write!(&mut created_container, "{}::C{}Templ<", Self::container_templ_path(), container_type).unwrap();
+                               self.write_template_generics(&mut created_container, &mut args.iter().map(|t| *t), generics, is_ref, true);
+                               writeln!(&mut created_container, ">;").unwrap();
 
-                       if !self.write_template_constructor(&mut created_container, container_type, &mangled_container, &args, generics, is_ref) {
-                               return false;
+                               write!(&mut created_container, "#[no_mangle]\npub static {}_free: extern \"C\" fn({}) = ", mangled_container, mangled_container).unwrap();
+                               write!(&mut created_container, "{}::C{}Templ_free::<", Self::container_templ_path(), container_type).unwrap();
+                               self.write_template_generics(&mut created_container, &mut args.iter().map(|t| *t), generics, is_ref, true);
+                               writeln!(&mut created_container, ">;").unwrap();
+
+                               if !self.write_template_constructor(&mut created_container, container_type, &mangled_container, &args, generics, is_ref) {
+                                       return false;
+                               }
                        }
                        self.crate_types.templates_defined.insert(mangled_container.clone(), true);
 

diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index dcb8d3078bb84bca61f42ef3a2c50b00b0d0becf..61006869aaa9bbeac4d630b20388bf88b23d6917 100644 (file)
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -256,14 +256,14 @@ impl Into<&'static str> for Str {
 // everywhere in the containers.
 
 #[repr(C)]
-pub union CResultPtr<O, E> {
-       pub result: *mut O,
-       pub err: *mut E,
+pub(crate) union CResultPtr<O, E> {
+       pub(crate) result: *mut O,
+       pub(crate) err: *mut E,
 }
 #[repr(C)]
-pub struct CResultTempl<O, E> {
-       pub contents: CResultPtr<O, E>,
-       pub result_ok: bool,
+pub(crate) struct CResultTempl<O, E> {
+       pub(crate) contents: CResultPtr<O, E>,
+       pub(crate) result_ok: bool,
 }
 impl<O, E> CResultTempl<O, E> {
        pub(crate) extern "C" fn ok(o: O) -> Self {
@@ -283,7 +283,6 @@ impl<O, E> CResultTempl<O, E> {
                }
        }
 }
-pub extern "C" fn CResultTempl_free<O, E>(_res: CResultTempl<O, E>) { }
 impl<O, E> Drop for CResultTempl<O, E> {
        fn drop(&mut self) {
                if self.result_ok {