add codegen tests for futures, streams, and error-contexts

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

Cargo.lock

@@ -31,6 +31,7 @@ clap = { version = "4.3.19", features = ["derive"] }
 indexmap = "2.0.0"
 prettyplease = "0.2.20"
 syn = { version = "2.0", features = ["printing"] }
+futures = "0.3.31"
 
 wasmparser = { git = "https://github.com/dicej/wasm-tools", branch = "async" }
 wasm-encoder = { git = "https://github.com/dicej/wasm-tools", branch = "async" }

Cargo.toml

@@ -1342,6 +1342,21 @@ void __wasm_export_{ns}_{snake}_dtor({ns}_{snake}_t* arg) {{
         self.finish_typedef_struct(id);
     }
 
+    fn type_future(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
+        _ = (id, name, ty, docs);
+        todo!()
+    }
+
+    fn type_stream(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs) {
+        _ = (id, name, ty, docs);
+        todo!()
+    }
+
+    fn type_error_context(&mut self, id: TypeId, name: &str, docs: &Docs) {
+        _ = (id, name, docs);
+        todo!()
+    }
+
     fn type_builtin(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs) {
         let _ = (id, name, ty, docs);
     }

crates/c/src/lib.rs

@@ -6,6 +6,14 @@ use std::process::Command;
 use wit_parser::{Resolve, UnresolvedPackageGroup};
 
 macro_rules! codegen_test {
+    // TODO: implement support for stream, future, and error-context, and then
+    // remove these lines:
+    (streams $name:tt $test:tt) => {};
+    (futures $name:tt $test:tt) => {};
+    (resources_with_streams $name:tt $test:tt) => {};
+    (resources_with_futures $name:tt $test:tt) => {};
+    (error_context $name:tt $test:tt) => {};
+
     ($id:ident $name:tt $test:tt) => {
         #[test]
         fn $id() {

crates/c/tests/codegen.rs

@@ -845,9 +845,7 @@ fn needs_post_return(resolve: &Resolve, ty: &Type) -> bool {
                 .filter_map(|t| t.as_ref())
                 .any(|t| needs_post_return(resolve, t)),
             TypeDefKind::Flags(_) | TypeDefKind::Enum(_) => false,
-            TypeDefKind::Future(_) | TypeDefKind::Stream(_) | TypeDefKind::ErrorContext => {
-                unimplemented!()
-            }
+            TypeDefKind::Future(_) | TypeDefKind::Stream(_) | TypeDefKind::ErrorContext => false,
             TypeDefKind::Unknown => unreachable!(),
         },
 

crates/core/src/abi.rs

@@ -170,6 +170,9 @@ pub trait InterfaceGenerator<'a> {
     fn type_alias(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
     fn type_list(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
     fn type_builtin(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
+    fn type_future(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs);
+    fn type_stream(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
+    fn type_error_context(&mut self, id: TypeId, name: &str, docs: &Docs);
     fn types(&mut self, iface: InterfaceId) {
         let iface = &self.resolve().interfaces[iface];
         for (name, id) in iface.types.iter() {
@@ -190,12 +193,10 @@ pub trait InterfaceGenerator<'a> {
             TypeDefKind::Result(r) => self.type_result(id, name, r, &ty.docs),
             TypeDefKind::List(t) => self.type_list(id, name, t, &ty.docs),
             TypeDefKind::Type(t) => self.type_alias(id, name, t, &ty.docs),
-            TypeDefKind::Future(_) => panic!("future types do not require definition"),
-            TypeDefKind::Stream(_) => panic!("stream types do not require definition"),
+            TypeDefKind::Future(t) => self.type_future(id, name, t, &ty.docs),
+            TypeDefKind::Stream(t) => self.type_stream(id, name, t, &ty.docs),
             TypeDefKind::Handle(_) => panic!("handle types do not require definition"),
-            TypeDefKind::ErrorContext => {
-                panic!("the error-context type does not require definition")
-            }
+            TypeDefKind::ErrorContext => self.type_error_context(id, name, &ty.docs),
             TypeDefKind::Unknown => unreachable!(),
         }
     }

crates/core/src/lib.rs

@@ -193,7 +193,9 @@ impl Types {
                 info = self.optional_type_info(resolve, r.ok.as_ref());
                 info |= self.optional_type_info(resolve, r.err.as_ref());
             }
-            TypeDefKind::Future(_) | TypeDefKind::Stream(_) | TypeDefKind::ErrorContext => {}
+            TypeDefKind::Future(_) | TypeDefKind::Stream(_) | TypeDefKind::ErrorContext => {
+                info.has_resource = true;
+            }
             TypeDefKind::Unknown => unreachable!(),
         }
         let prev = self.type_info.insert(ty, info);

crates/core/src/types.rs

@@ -1903,6 +1903,21 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
         self.type_name(&Type::Id(id));
     }
 
+    fn type_future(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
+        _ = (id, name, ty, docs);
+        todo!()
+    }
+
+    fn type_stream(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs) {
+        _ = (id, name, ty, docs);
+        todo!()
+    }
+
+    fn type_error_context(&mut self, id: TypeId, name: &str, docs: &Docs) {
+        _ = (id, name, docs);
+        todo!()
+    }
+
     fn type_builtin(&mut self, _id: TypeId, _name: &str, _ty: &Type, _docs: &Docs) {
         unimplemented!();
     }

crates/csharp/src/lib.rs

@@ -8,6 +8,14 @@ use std::{
 use wit_component::StringEncoding;
 
 macro_rules! codegen_test {
+    // TODO: implement support for stream, future, and error-context, and then
+    // remove these lines:
+    (streams $name:tt $test:tt) => {};
+    (futures $name:tt $test:tt) => {};
+    (resources_with_streams $name:tt $test:tt) => {};
+    (resources_with_futures $name:tt $test:tt) => {};
+    (error_context $name:tt $test:tt) => {};
+
     ($id:ident $name:tt $test:tt) => {
         #[test]
         fn $id() {

crates/csharp/tests/codegen.rs

@@ -1266,6 +1266,21 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
         // no impl since these types are generated as anonymous types
     }
 
+    fn type_future(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
+        _ = (id, name, ty, docs);
+        todo!()
+    }
+
+    fn type_stream(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs) {
+        _ = (id, name, ty, docs);
+        todo!()
+    }
+
+    fn type_error_context(&mut self, id: TypeId, name: &str, docs: &Docs) {
+        _ = (id, name, docs);
+        todo!()
+    }
+
     fn type_builtin(&mut self, _id: TypeId, _name: &str, _ty: &Type, _docs: &Docs) {
         todo!("type_builtin")
     }