Merge pull request #177 from alexcrichton/re-enable-concurrent-expanded-tests

Re-enable concurrent expansion tests

Author: alexcrichton

crates/component-macro/tests/expanded.rs

@@ -15,14 +15,13 @@ macro_rules! genexpand {
             stringify: true,
         }))?;
 
-        // TODO: re-enable this when wasip3 is merged back into this repo
-        // process_expanded($path, "_concurrent", wasmtime::component::bindgen!({
-        //     path: $path,
-        //     async: true,
-        //     concurrent_imports: true,
-        //     concurrent_exports: true,
-        //     stringify: true,
-        // }))?;
+        process_expanded($path, "_concurrent", wasmtime::component::bindgen!({
+            path: $path,
+            async: true,
+            concurrent_imports: true,
+            concurrent_exports: true,
+            stringify: true,
+        }))?;
 
         process_expanded($path, "_tracing_async", wasmtime::component::bindgen!({
             path: $path,

crates/component-macro/tests/expanded/char_concurrent.rs

@@ -155,18 +155,9 @@ const _: () = {
             host_getter: fn(&mut T) -> D::Data<'_>,
         ) -> wasmtime::Result<()>
         where
-<<<<<<< HEAD
             D: foo::foo::chars::HostConcurrent + Send,
             for<'a> D::Data<'a>: foo::foo::chars::Host + Send,
             T: 'static + Send,
-||||||| 40315bd2c
-            T: Send + foo::foo::chars::Host<Data = T> + 'static,
-            U: Send + foo::foo::chars::Host<Data = T>,
-=======
-            T: 'static,
-            T: Send + foo::foo::chars::Host<Data = T>,
-            U: Send + foo::foo::chars::Host<Data = T>,
->>>>>>> upstream/main
         {
             foo::foo::chars::add_to_linker::<T, D>(linker, host_getter)?;
             Ok(())
@@ -198,50 +189,17 @@ pub mod foo {
                 where
                     Self: Sized;
             }
-<<<<<<< HEAD
             #[wasmtime::component::__internal::trait_variant_make(::core::marker::Send)]
             pub trait Host: Send {}
-            impl<_T: Host + Send> Host for &mut _T {}
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
             pub fn add_to_linker<T, D>(
-||||||| 40315bd2c
-            pub trait GetHost<
-                T,
-                D,
-            >: Fn(T) -> <Self as GetHost<T, D>>::Host + Send + Sync + Copy + 'static {
-                type Host: Host<Data = D> + Send;
-            }
-            impl<F, T, D, O> GetHost<T, D> for F
-            where
-                F: Fn(T) -> O + Send + Sync + Copy + 'static,
-                O: Host<Data = D> + Send,
-            {
-                type Host = O;
-            }
-            pub fn add_to_linker_get_host<
-                T,
-                G: for<'a> GetHost<&'a mut T, T, Host: Host<Data = T> + Send>,
-            >(
-=======
-            pub fn add_to_linker_get_host<T, G>(
->>>>>>> upstream/main
                 linker: &mut wasmtime::component::Linker<T>,
                 host_getter: fn(&mut T) -> D::Data<'_>,
             ) -> wasmtime::Result<()>
             where
-<<<<<<< HEAD
                 D: HostConcurrent,
                 for<'a> D::Data<'a>: Host,
                 T: 'static + Send,
-||||||| 40315bd2c
-                T: Send + 'static,
-=======
-                T: 'static,
-                G: for<'a> wasmtime::component::GetHost<
-                    &'a mut T,
-                    Host: Host<Data = T> + Send,
-                >,
-                T: Send + 'static,
->>>>>>> upstream/main
             {
                 let mut inst = linker.instance("foo:foo/chars")?;
                 inst.func_wrap_concurrent(
@@ -270,91 +228,6 @@ pub mod foo {
                 )?;
                 Ok(())
             }
-<<<<<<< HEAD
-||||||| 40315bd2c
-            pub fn add_to_linker<T, U>(
-                linker: &mut wasmtime::component::Linker<T>,
-                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
-            ) -> wasmtime::Result<()>
-            where
-                U: Host<Data = T> + Send,
-                T: Send + 'static,
-            {
-                add_to_linker_get_host(linker, get)
-            }
-            impl<_T: Host> Host for &mut _T {
-                type Data = _T::Data;
-                /// A function that accepts a character
-                fn take_char(
-                    store: wasmtime::StoreContextMut<'_, Self::Data>,
-                    x: char,
-                ) -> impl ::core::future::Future<
-                    Output = impl FnOnce(
-                        wasmtime::StoreContextMut<'_, Self::Data>,
-                    ) -> () + Send + Sync + 'static,
-                > + Send + Sync + 'static
-                where
-                    Self: Sized,
-                {
-                    <_T as Host>::take_char(store, x)
-                }
-                /// A function that returns a character
-                fn return_char(
-                    store: wasmtime::StoreContextMut<'_, Self::Data>,
-                ) -> impl ::core::future::Future<
-                    Output = impl FnOnce(
-                        wasmtime::StoreContextMut<'_, Self::Data>,
-                    ) -> char + Send + Sync + 'static,
-                > + Send + Sync + 'static
-                where
-                    Self: Sized,
-                {
-                    <_T as Host>::return_char(store)
-                }
-            }
-=======
-            pub fn add_to_linker<T, U>(
-                linker: &mut wasmtime::component::Linker<T>,
-                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
-            ) -> wasmtime::Result<()>
-            where
-                T: 'static,
-                U: Host<Data = T> + Send,
-                T: Send + 'static,
-            {
-                add_to_linker_get_host(linker, get)
-            }
-            impl<_T: Host> Host for &mut _T {
-                type Data = _T::Data;
-                /// A function that accepts a character
-                fn take_char(
-                    store: wasmtime::StoreContextMut<'_, Self::Data>,
-                    x: char,
-                ) -> impl ::core::future::Future<
-                    Output = impl FnOnce(
-                        wasmtime::StoreContextMut<'_, Self::Data>,
-                    ) -> () + Send + Sync + 'static,
-                > + Send + Sync + 'static
-                where
-                    Self: Sized,
-                {
-                    <_T as Host>::take_char(store, x)
-                }
-                /// A function that returns a character
-                fn return_char(
-                    store: wasmtime::StoreContextMut<'_, Self::Data>,
-                ) -> impl ::core::future::Future<
-                    Output = impl FnOnce(
-                        wasmtime::StoreContextMut<'_, Self::Data>,
-                    ) -> char + Send + Sync + 'static,
-                > + Send + Sync + 'static
-                where
-                    Self: Sized,
-                {
-                    <_T as Host>::return_char(store)
-                }
-            }
->>>>>>> upstream/main
         }
     }
 }