[workerd-cxx] initial async C++ functions support (#16)

Can't test int & struct yet b/c of mistake in kj-rs.

Author: mikea

MODULE.bazel.lock

@@ -43,6 +43,7 @@ pub(crate) struct Includes<'a> {
     pub basetsd: bool,
     pub sys_types: bool,
     pub content: Content<'a>,
+    pub kj_rs: bool,
 }
 
 impl<'a> Includes<'a> {
@@ -105,6 +106,7 @@ pub(super) fn write(out: &mut OutFile) {
         vector,
         basetsd,
         sys_types,
+        kj_rs,
         content: _,
     } = *include;
 
@@ -186,6 +188,9 @@ pub(super) fn write(out: &mut OutFile) {
         writeln!(out, "#include <ranges>");
         writeln!(out, "#endif");
     }
+    if kj_rs && !cxx_header {
+        writeln!(out, "#include <kj-rs/promise.h>");
+    }
 }
 
 impl<'i, 'a> Extend<&'i Include> for Includes<'a> {

gen/src/include.rs

@@ -223,6 +223,7 @@ fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
             Type::SliceRef(_) => out.builtin.rust_slice = true,
             Type::Array(_) => out.include.array = true,
             Type::Ref(_) | Type::Void(_) | Type::Ptr(_) => {}
+            Type::Future(_) => out.include.kj_rs = true,
         }
     }
 }
@@ -1146,6 +1147,7 @@ fn write_indirect_return_type(out: &mut OutFile, ty: &Type) {
             }
             write!(out, "*");
         }
+        Type::Future(_) => write!(out, "kj_rs::repr::KjPromiseNodeImpl"),
         _ => write_type(out, ty),
     }
 }
@@ -1280,7 +1282,12 @@ fn write_type(out: &mut OutFile, ty: &Type) {
             write_type(out, &a.inner);
             write!(out, ", {}>", &a.len);
         }
-        Type::Void(_) => unreachable!(),
+        Type::Void(_) => write!(out, "void"),
+        Type::Future(ty) => {
+            write!(out, "kj::Promise<");
+            write_type(out, &ty.output);
+            write!(out, ">");
+        }
     }
 }
 
@@ -1325,6 +1332,7 @@ fn write_space_after_type(out: &mut OutFile, ty: &Type) {
         | Type::Array(_) => write!(out, " "),
         Type::Ref(_) | Type::Ptr(_) => {}
         Type::Void(_) => unreachable!(),
+        Type::Future(_) => write!(out, " "),
     }
 }
 

gen/src/write.rs

@@ -1,2 +1,18 @@
+alias w := watch
+alias b := build
+alias t := test
+
+watch +WATCH_TARGET='test':
+    watchexec -rc -w tests -w src -w gen -w macro -w syntax -- just {{WATCH_TARGET}}
+
+build:
+    bazel build //...
+
+test:
+    bazel test //...
+
+clippy:
+    bazel build --config=clippy  //...
+
 cargo-update:
     bazel run //third-party:vendor

justfile

@@ -1,11 +1,11 @@
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 
-URL = "https://github.com/capnproto/kj-rs/tarball/9fc9de649bbf9832d343cebc1c6cb84f47191f77"
-STRIP_PREFIX = "capnproto-kj-rs-9fc9de6"
-SHA256 = "25513ed21ca27471520e65fb126dca2ceff50c3d06e3056005febc28ee39e408"
+URL = "https://github.com/capnproto/kj-rs/tarball/13f2152e0cca109b0c64f9eeca4f62bcf0689a87"
+STRIP_PREFIX = "capnproto-kj-rs-13f2152"
+SHA256 = "bcd3b2b22a422936bebb5fcefa56eb7d4fa076e329fb6214683c4d6b5e7ec4c3"
 TYPE = "tgz"
-COMMIT = "9fc9de649bbf9832d343cebc1c6cb84f47191f77"
+COMMIT = "13f2152e0cca109b0c64f9eeca4f62bcf0689a87"
 
 def _kj_rs(_ctx):
     http_archive(

kj_rs.bzl

@@ -14,6 +14,7 @@ use crate::type_id::Crate;
 use crate::{derive, generics};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::spanned::Spanned;
 use std::mem;
 use syn::{parse_quote, punctuated, Generics, Lifetime, Result, Token};
 
@@ -77,6 +78,9 @@ fn expand(ffi: Module, doc: Doc, attrs: OtherAttrs, apis: &[Api], types: &Types)
                 }
             }
             Api::CxxFunction(efn) => {
+                if efn.asyncness.is_some() {
+                    // todo!("expand_cxx_function_shim\n{}", expand_cxx_function_shim(efn, types).to_string());
+                }
                 expanded.extend(expand_cxx_function_shim(efn, types));
             }
             Api::RustType(ety) => {
@@ -719,7 +723,10 @@ fn expand_cxx_function_shim(efn: &ExternFn, types: &Types) -> TokenStream {
                         false => quote_spanned!(span=> #call.as_slice::<#inner>()),
                         true => quote_spanned!(span=> #call.as_mut_slice::<#inner>()),
                     }
-                }
+                },
+                Type::Future(_) => {
+                    quote_spanned!(span=> ::kj_rs::new_callbacks_promise_future(#call))
+                },
                 _ => call,
             },
         };
@@ -1932,6 +1939,10 @@ fn expand_extern_type(ty: &Type, types: &Types, proper: bool) -> TokenStream {
             let rust_slice = Ident::new("RustSlice", ty.bracket.span.join());
             quote_spanned!(span=> ::cxx::private::#rust_slice)
         }
+        Type::Future(ty) => {
+            let span = ty.span();
+            quote_spanned!(span=> ::kj_rs::KjPromiseNodeImpl)
+        }
         _ => quote!(#ty),
     }
 }

macro/src/expand.rs

@@ -3,7 +3,7 @@ use crate::syntax::report::Errors;
 use crate::syntax::visit::{self, Visit};
 use crate::syntax::{
     error, ident, trivial, Api, Array, Enum, ExternFn, ExternType, Impl, Lang, Lifetimes,
-    NamedType, Ptr, Receiver, Ref, Signature, SliceRef, Struct, Trait, Ty1, Type, TypeAlias, Types,
+    NamedType, Ptr, Receiver, Ref, Signature, SliceRef, Struct, Trait, Ty1, Type, TypeAlias, Types, Future
 };
 use proc_macro2::{Delimiter, Group, Ident, TokenStream};
 use quote::{quote, ToTokens};
@@ -43,21 +43,7 @@ fn do_typecheck(cx: &mut Check) {
     ident::check_all(cx, cx.apis);
 
     for ty in cx.types {
-        match ty {
-            Type::Ident(ident) => check_type_ident(cx, ident),
-            Type::RustBox(ptr) => check_type_box(cx, ptr),
-            Type::RustVec(ty) => check_type_rust_vec(cx, ty),
-            Type::UniquePtr(ptr) => check_type_unique_ptr(cx, ptr),
-            Type::SharedPtr(ptr) => check_type_shared_ptr(cx, ptr),
-            Type::WeakPtr(ptr) => check_type_weak_ptr(cx, ptr),
-            Type::CxxVector(ptr) => check_type_cxx_vector(cx, ptr),
-            Type::Ref(ty) => check_type_ref(cx, ty),
-            Type::Ptr(ty) => check_type_ptr(cx, ty),
-            Type::Array(array) => check_type_array(cx, array),
-            Type::Fn(ty) => check_type_fn(cx, ty),
-            Type::SliceRef(ty) => check_type_slice_ref(cx, ty),
-            Type::Str(_) | Type::Void(_) => {}
-        }
+        check_type(cx, ty);
     }
 
     for api in cx.apis {
@@ -79,6 +65,25 @@ impl Check<'_> {
     }
 }
 
+fn check_type(cx: &mut Check, ty: &Type) {
+    match ty {
+        Type::Ident(ident) => check_type_ident(cx, ident),
+        Type::RustBox(ptr) => check_type_box(cx, ptr),
+        Type::RustVec(ty) => check_type_rust_vec(cx, ty),
+        Type::UniquePtr(ptr) => check_type_unique_ptr(cx, ptr),
+        Type::SharedPtr(ptr) => check_type_shared_ptr(cx, ptr),
+        Type::WeakPtr(ptr) => check_type_weak_ptr(cx, ptr),
+        Type::CxxVector(ptr) => check_type_cxx_vector(cx, ptr),
+        Type::Ref(ty) => check_type_ref(cx, ty),
+        Type::Ptr(ty) => check_type_ptr(cx, ty),
+        Type::Array(array) => check_type_array(cx, array),
+        Type::Fn(ty) => check_type_fn(cx, ty),
+        Type::SliceRef(ty) => check_type_slice_ref(cx, ty),
+        Type::Str(_) | Type::Void(_) => {}
+        Type::Future(ty) => check_type_future(cx, ty),
+    }
+}
+
 fn check_type_ident(cx: &mut Check, name: &NamedType) {
     let ident = &name.rust;
     if Atom::from(ident).is_none()
@@ -640,6 +645,10 @@ fn check_generics(cx: &mut Check, generics: &Generics) {
     }
 }
 
+fn check_type_future(cx: &mut Check, f: &Future) {
+    check_type(cx, &f.output);
+}
+
 fn is_unsized(cx: &mut Check, ty: &Type) -> bool {
     match ty {
         Type::Ident(ident) => {
@@ -657,6 +666,7 @@ fn is_unsized(cx: &mut Check, ty: &Type) -> bool {
         | Type::Ptr(_)
         | Type::Str(_)
         | Type::SliceRef(_) => false,
+        Type::Future(_) => false,
     }
 }
 
@@ -735,5 +745,6 @@ fn describe(cx: &mut Check, ty: &Type) -> String {
         Type::Fn(_) => "function pointer".to_owned(),
         Type::Void(_) => "()".to_owned(),
         Type::Array(_) => "array".to_owned(),
+        Type::Future(f) => format!("Future<Output = {}>", describe(cx, &f.output)),
     }
 }

syntax/check.rs

@@ -1,5 +1,6 @@
 use crate::syntax::{
-    Array, ExternFn, Include, Lifetimes, Ptr, Receiver, Ref, Signature, SliceRef, Ty1, Type, Var,
+    Array, ExternFn, Future, Include, Lifetimes, Ptr, Receiver, Ref, Signature, SliceRef, Ty1,
+    Type, Var,
 };
 use std::hash::{Hash, Hasher};
 use std::mem;
@@ -57,6 +58,7 @@ impl Hash for Type {
             Type::SliceRef(t) => t.hash(state),
             Type::Array(t) => t.hash(state),
             Type::Void(_) => {}
+            Type::Future(t) => t.hash(state),
         }
     }
 }
@@ -78,6 +80,7 @@ impl PartialEq for Type {
             (Type::Fn(lhs), Type::Fn(rhs)) => lhs == rhs,
             (Type::SliceRef(lhs), Type::SliceRef(rhs)) => lhs == rhs,
             (Type::Void(_), Type::Void(_)) => true,
+            (Type::Future(lhs), Type::Future(rhs)) => lhs == rhs,
             (_, _) => false,
         }
     }
@@ -290,6 +293,12 @@ impl PartialEq for Array {
     }
 }
 
+impl PartialEq for Future {
+    fn eq(&self, other: &Self) -> bool {
+        self.output == other.output
+    }
+}
+
 impl Hash for Array {
     fn hash<H: Hasher>(&self, state: &mut H) {
         let Array {
@@ -304,6 +313,12 @@ impl Hash for Array {
     }
 }
 
+impl Hash for Future {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.output.hash(state);
+    }
+}
+
 impl Eq for Signature {}
 
 impl PartialEq for Signature {

syntax/impls.rs

@@ -34,6 +34,7 @@ impl<'a> Types<'a> {
             Type::Ref(ty) => self.determine_improper_ctype(&ty.inner),
             Type::Ptr(ty) => self.determine_improper_ctype(&ty.inner),
             Type::Array(ty) => self.determine_improper_ctype(&ty.inner),
+            Type::Future(_) => todo!("file a workerd-cxx ticket"),
         }
     }
 }

syntax/improper.rs

@@ -275,6 +275,7 @@ pub(crate) enum Type {
     Void(Span),
     SliceRef(Box<SliceRef>),
     Array(Box<Array>),
+    Future(Box<Future>),
 }
 
 pub(crate) struct Ty1 {
@@ -319,6 +320,10 @@ pub(crate) struct Array {
     pub len_token: LitInt,
 }
 
+pub(crate) struct Future {
+    pub output: Type,
+}
+
 #[derive(Copy, Clone, PartialEq)]
 pub(crate) enum Lang {
     Cxx,