Try to get the rebase passing tests, not working

Author: alexcrichton

crates/wasmtime/src/runtime/component/func.rs

@@ -290,9 +290,22 @@ impl Func {
             store.0.async_support(),
             "cannot use `call_async` without enabling async support in the config"
         );
-        store
-            .on_fiber(|store| self.call_impl(store, params, results))
-            .await?
+        #[cfg(feature = "component-model-async")]
+        {
+            let future = self.call_concurrent(store.as_context_mut(), params.to_vec());
+            let run_results = self.instance.run(store, future).await??;
+            assert_eq!(run_results.len(), results.len());
+            for (result, slot) in run_results.into_iter().zip(results) {
+                *slot = result;
+            }
+            Ok(())
+        }
+        #[cfg(not(feature = "component-model-async"))]
+        {
+            store
+                .on_fiber(|store| self.call_impl(store, params, results))
+                .await?
+        }
     }
 
     #[cfg(feature = "component-model-async")]

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -180,15 +180,28 @@ where
         &self,
         mut store: impl AsContextMut<Data: Send>,
         params: Params,
-    ) -> Result<Return> {
+    ) -> Result<Return>
+    where
+        Params: 'static,
+        Return: 'static,
+    {
         let mut store = store.as_context_mut();
         assert!(
             store.0.async_support(),
             "cannot use `call_async` when async support is not enabled on the config"
         );
-        store
-            .on_fiber(|store| self.call_impl(store, params))
-            .await?
+        #[cfg(feature = "component-model-async")]
+        {
+            let prepared = self.prepare_call(store.as_context_mut(), params)?;
+            let call = concurrent::queue_call(store.as_context_mut(), prepared)?;
+            self.func.instance.run(store, call).await?
+        }
+        #[cfg(not(feature = "component-model-async"))]
+        {
+            store
+                .on_fiber(|store| self.call_impl(store, params))
+                .await?
+        }
     }
 
     /// Start a concurrent call to this function.

crates/wit-bindgen/src/lib.rs

@@ -2745,10 +2745,10 @@ impl<'a> InterfaceGenerator<'a> {
             func.item_name().to_snake_case(),
         );
 
-        let param_mode = if let CallStyle::Concurrent = &style {
-            TypeMode::Owned
-        } else {
+        let param_mode = if let CallStyle::Sync = &style {
             TypeMode::AllBorrowed("'_")
+        } else {
+            TypeMode::Owned
         };
 
         for (i, param) in func.params.iter().enumerate() {

examples/resource-component/main.rs

@@ -138,11 +138,11 @@ async fn main() -> Result<()> {
     let component = Component::from_file(&engine, "target/wasm32-wasip2/debug/guest_kvdb.wasm")?;
     let bindings = KvDatabase::instantiate_async(&mut store, &component, &linker).await?;
     let result = bindings
-        .call_replace_value(&mut store, "hello", "world")
+        .call_replace_value(&mut store, "hello".to_string(), "world".to_string())
         .await?;
     assert_eq!(result, None);
     let result = bindings
-        .call_replace_value(&mut store, "hello", "wasmtime")
+        .call_replace_value(&mut store, "hello".to_string(), "wasmtime".to_string())
         .await?;
     assert_eq!(result, Some("world".to_string()));
     Ok(())