cxx function

gen/src/mod.rs

@@ -163,7 +163,7 @@ pub(super) fn generate(syntax: File, opt: &Opt) -> Result<GeneratedCode> {
     cfg::strip(errors, cfg_errors, opt.cfg_evaluator.as_ref(), apis);
     errors.propagate()?;
 
-    let ref types = Types::collect(errors, apis);
+    let ref types = Types::collect(errors, &apis);
     check::precheck(errors, apis, opt);
     errors.propagate()?;
 

gen/src/write.rs

@@ -3,7 +3,7 @@ use crate::gen::nested::NamespaceEntries;
 use crate::gen::out::OutFile;
 use crate::gen::{builtin, include, Opt};
 use crate::syntax::atom::Atom::{self, *};
-use crate::syntax::instantiate::{ImplKey, NamedImplKey};
+use crate::syntax::instantiate::{FunctionImplKey, ImplKey, NamedImplKey};
 use crate::syntax::map::UnorderedMap as Map;
 use crate::syntax::set::UnorderedSet;
 use crate::syntax::symbol::{self, Symbol};
@@ -218,6 +218,7 @@ fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
             Type::SharedPtr(_) | Type::WeakPtr(_) => out.include.memory = true,
             Type::Str(_) => out.builtin.rust_str = true,
             Type::CxxVector(_) => out.include.vector = true,
+            Type::CxxFunction(_) => out.include.functional = true,
             Type::Fn(_) => out.builtin.rust_fn = true,
             Type::SliceRef(_) => out.builtin.rust_slice = true,
             Type::Array(_) => out.include.array = true,
@@ -1255,6 +1256,25 @@ fn write_type(out: &mut OutFile, ty: &Type) {
             write_type(out, &ty.inner);
             write!(out, ">");
         }
+        Type::CxxFunction(ty) => {
+            if let Type::Fn(f) = &ty.inner {
+                write!(out, "::std::function<");
+                match &f.ret {
+                    Some(ret) => write_type(out, ret),
+                    None => write!(out, "void"),
+                }
+                write!(out, "(");
+                for (i, arg) in f.args.iter().enumerate() {
+                    if i > 0 {
+                        write!(out, ", ");
+                    }
+                    write_type(out, &arg.ty);
+                }
+                write!(out, ")>");
+            } else {
+                unreachable!("should not have produced a CxxFunction with non-Fn inner")
+            }
+        }
         Type::Ref(r) => {
             write_type_space(out, &r.inner);
             if !r.mutable {
@@ -1339,6 +1359,7 @@ fn write_space_after_type(out: &mut OutFile, ty: &Type) {
         | Type::WeakPtr(_)
         | Type::Str(_)
         | Type::CxxVector(_)
+        | Type::CxxFunction(_)
         | Type::RustVec(_)
         | Type::SliceRef(_)
         | Type::Fn(_)
@@ -1413,6 +1434,7 @@ fn write_generic_instantiations(out: &mut OutFile) {
             ImplKey::SharedPtr(ident) => write_shared_ptr(out, ident),
             ImplKey::WeakPtr(ident) => write_weak_ptr(out, ident),
             ImplKey::CxxVector(ident) => write_cxx_vector(out, ident),
+            ImplKey::CxxFunction(ref key) => write_cxx_function(out, key),
         }
     }
     out.end_block(Block::ExternC);
@@ -1956,3 +1978,63 @@ fn write_cxx_vector(out: &mut OutFile, key: NamedImplKey) {
     out.include.memory = true;
     write_unique_ptr_common(out, UniquePtr::CxxVector(element));
 }
+
+fn write_cxx_function(out: &mut OutFile, key: &FunctionImplKey) {
+    begin_function_definition(out);
+
+    // let link_invoke = {
+    //     let ret_str = if let Some(ret) = key.ret {
+    //         ret.to_typename(out.types).to_string()
+    //     } else {
+    //         "".to_string()
+    //     };
+
+    //     let mut prefix = format!("cxxbridge1$std$function${}", ret_str);
+    //     for arg in &key.args {
+    //         write!(&mut prefix, "${}", out.types.resolve(*arg).name.to_symbol()).unwrap();
+    //     }
+    //     prefix.push('$');
+
+    //     format!("{}invoke", prefix)
+    // };
+    let link_invoke = key.link_name_invoke(out.types);
+
+    if let Type::CxxFunction(ty) = key.ty {
+        if let Type::Fn(sig) = &ty.inner {
+            if let Some(ret) = &sig.ret {
+                write_type(out, &ret);
+            } else {
+                write!(out, "void")
+            }
+            // let cpp_ret = key
+            //     .ret
+            //     .map(|r| {
+            //         // if let Some(atom) = Atom::from(r) {
+            //         //     atom.to_string()
+            //         // } else {
+            //         //     r.to_mangled(&out.types).to_string()
+            //         // }
+            //     })
+            //     .unwrap_or_else(|| "void".to_owned());
+
+            write!(out, " {link_invoke}(");
+            write_type(out, &key.ty);
+            write!(out, " f");
+            for (id, a) in sig.args.iter().enumerate() {
+                write!(out, ", ");
+                write_type(out, &a.ty);
+                write!(out, " a_{id}");
+            }
+            writeln!(out, ") {{");
+            write!(out, "  return f(");
+            for id in 0..sig.args.len() {
+                write!(out, "a_{id}");
+                if id != sig.args.len() - 1 {
+                    write!(out, ", ");
+                }
+            }
+            writeln!(out, ");");
+            writeln!(out, "}}");
+        }
+    }
+}

macro/Cargo.toml

@@ -23,7 +23,7 @@ experimental-enum-variants-from-header = ["clang-ast", "flate2", "memmap", "serd
 [dependencies]
 proc-macro2 = "1.0.63"
 quote = "1.0.29"
-syn = { version = "2.0.23", features = ["full"] }
+syn = { version = "2.0.23", features = ["full", "extra-traits"] }
 
 # optional dependencies:
 clang-ast = { version = "0.1.18", optional = true }
@@ -32,6 +32,7 @@ memmap = { version = "0.7", optional = true }
 serde = { version = "1.0.166", optional = true }
 serde_derive = { version = "1.0.166", optional = true }
 serde_json = { version = "1.0.100", optional = true }
+libc = "0.2.150"
 
 [dev-dependencies]
 cxx = { version = "1.0", path = ".." }

macro/src/expand.rs

@@ -2,13 +2,13 @@ use crate::syntax::atom::Atom::*;
 use crate::syntax::attrs::{self, OtherAttrs};
 use crate::syntax::cfg::CfgExpr;
 use crate::syntax::file::Module;
-use crate::syntax::instantiate::{ImplKey, NamedImplKey};
+use crate::syntax::instantiate::{FunctionImplKey, ImplKey, NamedImplKey};
 use crate::syntax::qualified::QualifiedName;
 use crate::syntax::report::Errors;
 use crate::syntax::symbol::Symbol;
 use crate::syntax::{
-    self, check, mangle, Api, Doc, Enum, ExternFn, ExternType, Impl, Lifetimes, Pair, Signature,
-    Struct, Trait, Type, TypeAlias, Types,
+    self, check, mangle, Api, Doc, Enum, ExternFn, ExternType, Impl, Lifetimes, Pair,
+    Signature, Struct, Trait, Type, TypeAlias, Types,
 };
 use crate::type_id::Crate;
 use crate::{derive, generics};
@@ -91,25 +91,35 @@ fn expand(ffi: Module, doc: Doc, attrs: OtherAttrs, apis: &[Api], types: &Types)
         }
     }
 
+    let mut first_cxx_function = true;
     for (impl_key, &explicit_impl) in &types.impls {
-        match *impl_key {
+        match impl_key {
             ImplKey::RustBox(ident) => {
-                hidden.extend(expand_rust_box(ident, types, explicit_impl));
+                hidden.extend(expand_rust_box(*ident, types, explicit_impl));
             }
             ImplKey::RustVec(ident) => {
-                hidden.extend(expand_rust_vec(ident, types, explicit_impl));
+                hidden.extend(expand_rust_vec(*ident, types, explicit_impl));
             }
             ImplKey::UniquePtr(ident) => {
-                expanded.extend(expand_unique_ptr(ident, types, explicit_impl));
+                expanded.extend(expand_unique_ptr(*ident, types, explicit_impl));
             }
             ImplKey::SharedPtr(ident) => {
-                expanded.extend(expand_shared_ptr(ident, types, explicit_impl));
+                expanded.extend(expand_shared_ptr(*ident, types, explicit_impl));
             }
             ImplKey::WeakPtr(ident) => {
-                expanded.extend(expand_weak_ptr(ident, types, explicit_impl));
+                expanded.extend(expand_weak_ptr(*ident, types, explicit_impl));
             }
             ImplKey::CxxVector(ident) => {
-                expanded.extend(expand_cxx_vector(ident, explicit_impl, types));
+                expanded.extend(expand_cxx_vector(*ident, explicit_impl, types));
+            }
+            ImplKey::CxxFunction(sig) => {
+                expanded.extend(expand_cxx_function(
+                    &sig,
+                    explicit_impl,
+                    types,
+                    first_cxx_function,
+                ));
+                first_cxx_function = false;
             }
         }
     }
@@ -1674,6 +1684,7 @@ fn expand_cxx_vector(
     let elem = key.rust;
     let name = elem.to_string();
     let resolve = types.resolve(elem);
+
     let prefix = format!("cxxbridge1$std$vector${}$", resolve.name.to_symbol());
     let link_new = format!("{}new", prefix);
     let link_size = format!("{}size", prefix);
@@ -1819,6 +1830,61 @@ fn expand_cxx_vector(
     }
 }
 
+fn expand_cxx_function(
+    key: &FunctionImplKey,
+    _explicit_impl: Option<&Impl>,
+    types: &Types,
+    first_cxx_function: bool,
+) -> TokenStream {
+    let link_invoke = key.link_name_invoke(types);
+
+    if let Type::CxxFunction(ty) = key.ty {
+        if let Type::Fn(sig) = &ty.inner {
+            let only_first_time = if first_cxx_function {
+                quote! {
+                    pub struct CrateFnImpls;
+                    pub type CxxFunction<F> = ::cxx::CxxFunction<CrateFnImpls, F>;
+                }
+            } else {
+                Default::default()
+            };
+
+            let ret = if let Some(Type::Ident(r)) = &sig.ret {
+                quote! { #r }
+            } else {
+                quote! { () }
+            };
+
+            let mut arg_types = quote!{};
+            let mut arg_names = quote!{};
+            let mut arg_type_names = quote!{};
+            for (id, a) in sig.args.iter().enumerate() {
+                if let Type::Ident(ident) = &a.ty {
+                    let arg_name = format_ident!("a_{id}");
+                    arg_types = quote!{ #arg_types #ident, };
+                    arg_names = quote!{ #arg_names #arg_name, };
+                    arg_type_names = quote!{ #arg_type_names #arg_name: #ident, };
+                }
+            }
+
+            return quote_spanned! {ty.name.span() =>
+                #only_first_time
+
+                unsafe impl ::cxx::private::CxxFunctionImpl<#ret, (#arg_types)> for CrateFnImpls {
+                    fn __invoke(this: *mut ::cxx::core::ffi::c_void, (#arg_names): (#arg_types)) -> #ret {
+                        extern "C" {
+                            #[link_name = #link_invoke]
+                            fn __function_invoke(this: *mut ::cxx::core::ffi::c_void, #arg_type_names) -> #ret;
+                        }
+                        unsafe { __function_invoke(this, #arg_names) }
+                    }
+                }
+            };
+        }
+    }
+    panic!("bad type");
+}
+
 fn expand_return_type(ret: &Option<Type>) -> TokenStream {
     match ret {
         Some(ret) => quote!(-> #ret),

src/cxx_function.rs

@@ -0,0 +1,37 @@
+use core::{ffi::c_void, marker::PhantomData};
+
+///
+pub unsafe trait CxxFunctionImpl<Ret, Args> {
+    #[doc(hidden)]
+    fn __invoke(f: *mut c_void, a: Args) -> Ret;
+}
+
+/// Bridge to std::function<Fn>
+#[repr(C)]
+pub struct CxxFunction<I: ?Sized, F> {
+    // A thing, because repr(C) structs are not allowed to consist exclusively
+    // of PhantomData fields.
+    _void: [c_void; 0],
+    _impl: PhantomData<I>,
+    _fn: PhantomData<F>,
+}
+
+impl<I, Out> CxxFunction<I, fn() -> Out>
+where
+    I: CxxFunctionImpl<Out, ()>,
+{
+    /// Run the std::function
+    pub fn invoke(&mut self) -> Out {
+        <I as CxxFunctionImpl<Out, ()>>::__invoke(self as *mut _ as _, ())
+    }
+}
+
+impl<I, In, Out> CxxFunction<I, fn(In) -> Out>
+where
+    I: CxxFunctionImpl<Out, (In,)>,
+{
+    /// Run the std::function
+    pub fn invoke(&mut self, a: In) -> Out {
+        <I as CxxFunctionImpl<Out, (In,)>>::__invoke(self as *mut _ as _, (a,))
+    }
+}

src/lib.rs

@@ -449,6 +449,7 @@ compile_error! {
 mod macros;
 
 mod c_char;
+mod cxx_function;
 mod cxx_vector;
 mod exception;
 mod extern_type;
@@ -475,6 +476,7 @@ mod unwind;
 pub mod vector;
 mod weak_ptr;
 
+pub use crate::cxx_function::CxxFunction;
 pub use crate::cxx_vector::CxxVector;
 #[cfg(feature = "alloc")]
 pub use crate::exception::Exception;
@@ -503,6 +505,7 @@ pub type Vector<T> = CxxVector<T>;
 #[doc(hidden)]
 pub mod private {
     pub use crate::c_char::c_char;
+    pub use crate::cxx_function::CxxFunctionImpl;
     pub use crate::cxx_vector::VectorElement;
     pub use crate::extern_type::{verify_extern_kind, verify_extern_type};
     pub use crate::function::FatFunction;