Merge pull request #219 from bytecodealliance/dicej/remove-unused-block-on-param

dicej · web-flow · commit 4cd979b71c6e · 2025-06-17T17:59:59.000Z
remove unused parameter from `AsyncCx::block_on`
diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rs
@@ -4417,15 +4417,14 @@ impl AsyncCx {
     pub(crate) unsafe fn block_on<U>(
         &self,
         mut future: Pin<&mut (dyn Future<Output = U> + Send)>,
-        mut store: Option<*mut dyn VMStore>,
-    ) -> Result<(U, Option<*mut dyn VMStore>)> {
+    ) -> Result<U> {
         loop {
             match self.poll(future.as_mut()) {
-                Poll::Ready(v) => break Ok((v, store)),
-                Poll::Pending => {}
+                Poll::Ready(v) => break Ok(v),
+                Poll::Pending => {
+                    self.suspend(None)?;
+                }
             }
-
-            store = self.suspend(store)?;
         }
     }
 
diff --git a/crates/wasmtime/src/runtime/component/linker.rs b/crates/wasmtime/src/runtime/component/linker.rs
@@ -447,7 +447,7 @@ impl<T: 'static> LinkerInstance<'_, T> {
             {
                 let async_cx = crate::component::concurrent::AsyncCx::new(&mut store.0);
                 let mut future = Pin::from(f(store.as_context_mut(), params));
-                unsafe { async_cx.block_on(future.as_mut(), None) }?.0
+                unsafe { async_cx.block_on(future.as_mut()) }?
             }
             #[cfg(not(feature = "component-model-async"))]
             {
@@ -622,7 +622,7 @@ impl<T: 'static> LinkerInstance<'_, T> {
             {
                 let async_cx = crate::component::concurrent::AsyncCx::new(&mut store.0);
                 let mut future = Pin::from(f(store.as_context_mut(), params, results));
-                unsafe { async_cx.block_on(future.as_mut(), None) }?.0
+                unsafe { async_cx.block_on(future.as_mut()) }?
             }
             #[cfg(not(feature = "component-model-async"))]
             {
@@ -732,7 +732,7 @@ impl<T: 'static> LinkerInstance<'_, T> {
                     let async_cx =
                         crate::component::concurrent::AsyncCx::new(&mut cx.as_context_mut().0);
                     let mut future = Pin::from(dtor(cx.as_context_mut(), param));
-                    unsafe { async_cx.block_on(future.as_mut(), None) }?.0
+                    unsafe { async_cx.block_on(future.as_mut()) }?
                 }
                 #[cfg(not(feature = "component-model-async"))]
                 {
diff --git a/crates/wasmtime/src/runtime/func.rs b/crates/wasmtime/src/runtime/func.rs
@@ -518,9 +518,9 @@ impl Func {
             {
                 let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);
                 let mut future = Pin::from(func(caller, params, results));
-                match unsafe { async_cx.block_on(future.as_mut(), None) } {
-                    Ok((Ok(()), _)) => Ok(()),
-                    Ok((Err(trap), _)) | Err(trap) => Err(trap),
+                match unsafe { async_cx.block_on(future.as_mut()) } {
+                    Ok(Ok(())) => Ok(()),
+                    Ok(Err(trap)) | Err(trap) => Err(trap),
                 }
             }
             #[cfg(not(feature = "component-model-async"))]
@@ -857,8 +857,8 @@ impl Func {
                 let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);
                 let mut future = Pin::from(func(caller, args));
 
-                match unsafe { async_cx.block_on(future.as_mut(), None) } {
-                    Ok((ret, _)) => ret.into_fallible(),
+                match unsafe { async_cx.block_on(future.as_mut()) } {
+                    Ok(ret) => ret.into_fallible(),
                     Err(e) => R::fallible_from_error(e),
                 }
             }
diff --git a/crates/wasmtime/src/runtime/linker.rs b/crates/wasmtime/src/runtime/linker.rs
@@ -475,9 +475,9 @@ impl<T> Linker<T> {
             {
                 let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);
                 let mut future = Pin::from(func(caller, params, results));
-                match unsafe { async_cx.block_on(future.as_mut(), None) } {
-                    Ok((Ok(()), _)) => Ok(()),
-                    Ok((Err(trap), _)) | Err(trap) => Err(trap),
+                match unsafe { async_cx.block_on(future.as_mut()) } {
+                    Ok(Ok(())) => Ok(()),
+                    Ok(Err(trap)) | Err(trap) => Err(trap),
                 }
             }
             #[cfg(not(feature = "component-model-async"))]
@@ -595,8 +595,8 @@ impl<T> Linker<T> {
                     let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);
                     let mut future = Pin::from(func(caller, args));
 
-                    match unsafe { async_cx.block_on(future.as_mut(), None) } {
-                        Ok((ret, _)) => ret.into_fallible(),
+                    match unsafe { async_cx.block_on(future.as_mut()) } {
+                        Ok(ret) => ret.into_fallible(),
                         Err(e) => Args::fallible_from_error(e),
                     }
                 }
diff --git a/crates/wasmtime/src/runtime/store/async_.rs b/crates/wasmtime/src/runtime/store/async_.rs
@@ -234,7 +234,7 @@ impl<T> StoreInner<T> {
                 .context("couldn't create AsyncCx to block on async operation")?;
             let future = mk_future(self);
             let mut future = core::pin::pin!(future);
-            unsafe { Ok(async_cx.block_on(future.as_mut(), None)?.0) }
+            unsafe { Ok(async_cx.block_on(future.as_mut())?) }
         }
         #[cfg(not(feature = "component-model-async"))]
         {
diff --git a/crates/wasmtime/src/runtime/store/gc.rs b/crates/wasmtime/src/runtime/store/gc.rs
@@ -51,7 +51,7 @@ impl StoreOpaque {
                 unsafe {
                     let async_cx = crate::component::concurrent::AsyncCx::new(&mut scope);
                     let future = scope.grow_or_collect_gc_heap_async(bytes_needed);
-                    async_cx.block_on(Box::pin(future).as_mut(), None)?.0;
+                    async_cx.block_on(Box::pin(future).as_mut())?;
                 }
             }
         } else {
diff --git a/crates/wasmtime/src/runtime/vm/stack_switching/stack/unix.rs b/crates/wasmtime/src/runtime/vm/stack_switching/stack/unix.rs
@@ -353,7 +353,7 @@ cfg_if::cfg_if! {
     if #[cfg(target_arch = "x86_64")] {
         mod x86_64;
     } else {
-        // Note that this shoul be unreachable: In stack.rs, we currently select
+        // Note that this should be unreachable: In stack.rs, we currently select
         // the module defined in the current file only if we are on unix AND
         // x86_64.
         compile_error!("the stack switching feature is not supported on this CPU architecture");

Original file line number	Diff line number	Diff line change
`@@ -447,7 +447,7 @@ impl<T: 'static> LinkerInstance<'_, T> {`
`447`	`447`	`{`
`448`	`448`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut store.0);`
`449`	`449`	`let mut future = Pin::from(f(store.as_context_mut(), params));`
`450`		`- unsafe { async_cx.block_on(future.as_mut(), None) }?.0`
	`450`	`+ unsafe { async_cx.block_on(future.as_mut()) }?`
`451`	`451`	`}`
`452`	`452`	`#[cfg(not(feature = "component-model-async"))]`
`453`	`453`	`{`
`@@ -622,7 +622,7 @@ impl<T: 'static> LinkerInstance<'_, T> {`
`622`	`622`	`{`
`623`	`623`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut store.0);`
`624`	`624`	`let mut future = Pin::from(f(store.as_context_mut(), params, results));`
`625`		`- unsafe { async_cx.block_on(future.as_mut(), None) }?.0`
	`625`	`+ unsafe { async_cx.block_on(future.as_mut()) }?`
`626`	`626`	`}`
`627`	`627`	`#[cfg(not(feature = "component-model-async"))]`
`628`	`628`	`{`
`@@ -732,7 +732,7 @@ impl<T: 'static> LinkerInstance<'_, T> {`
`732`	`732`	`let async_cx =`
`733`	`733`	`crate::component::concurrent::AsyncCx::new(&mut cx.as_context_mut().0);`
`734`	`734`	`let mut future = Pin::from(dtor(cx.as_context_mut(), param));`
`735`		`- unsafe { async_cx.block_on(future.as_mut(), None) }?.0`
	`735`	`+ unsafe { async_cx.block_on(future.as_mut()) }?`
`736`	`736`	`}`
`737`	`737`	`#[cfg(not(feature = "component-model-async"))]`
`738`	`738`	`{`
Original file line number	Diff line number	Diff line change
`@@ -518,9 +518,9 @@ impl Func {`
`518`	`518`	`{`
`519`	`519`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);`
`520`	`520`	`let mut future = Pin::from(func(caller, params, results));`
`521`		`- match unsafe { async_cx.block_on(future.as_mut(), None) } {`
`522`		`- Ok((Ok(()), _)) => Ok(()),`
`523`		`- Ok((Err(trap), _)) \| Err(trap) => Err(trap),`
	`521`	`+ match unsafe { async_cx.block_on(future.as_mut()) } {`
	`522`	`+ Ok(Ok(())) => Ok(()),`
	`523`	`+ Ok(Err(trap)) \| Err(trap) => Err(trap),`
`524`	`524`	`}`
`525`	`525`	`}`
`526`	`526`	`#[cfg(not(feature = "component-model-async"))]`
`@@ -857,8 +857,8 @@ impl Func {`
`857`	`857`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);`
`858`	`858`	`let mut future = Pin::from(func(caller, args));`
`859`	`859`
`860`		`- match unsafe { async_cx.block_on(future.as_mut(), None) } {`
`861`		`- Ok((ret, _)) => ret.into_fallible(),`
	`860`	`+ match unsafe { async_cx.block_on(future.as_mut()) } {`
	`861`	`+ Ok(ret) => ret.into_fallible(),`
`862`	`862`	`Err(e) => R::fallible_from_error(e),`
`863`	`863`	`}`
`864`	`864`	`}`
Original file line number	Diff line number	Diff line change
`@@ -475,9 +475,9 @@ impl<T> Linker<T> {`
`475`	`475`	`{`
`476`	`476`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);`
`477`	`477`	`let mut future = Pin::from(func(caller, params, results));`
`478`		`- match unsafe { async_cx.block_on(future.as_mut(), None) } {`
`479`		`- Ok((Ok(()), _)) => Ok(()),`
`480`		`- Ok((Err(trap), _)) \| Err(trap) => Err(trap),`
	`478`	`+ match unsafe { async_cx.block_on(future.as_mut()) } {`
	`479`	`+ Ok(Ok(())) => Ok(()),`
	`480`	`+ Ok(Err(trap)) \| Err(trap) => Err(trap),`
`481`	`481`	`}`
`482`	`482`	`}`
`483`	`483`	`#[cfg(not(feature = "component-model-async"))]`
`@@ -595,8 +595,8 @@ impl<T> Linker<T> {`
`595`	`595`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut caller.store.0);`
`596`	`596`	`let mut future = Pin::from(func(caller, args));`
`597`	`597`
`598`		`- match unsafe { async_cx.block_on(future.as_mut(), None) } {`
`599`		`- Ok((ret, _)) => ret.into_fallible(),`
	`598`	`+ match unsafe { async_cx.block_on(future.as_mut()) } {`
	`599`	`+ Ok(ret) => ret.into_fallible(),`
`600`	`600`	`Err(e) => Args::fallible_from_error(e),`
`601`	`601`	`}`
`602`	`602`	`}`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ impl<T> StoreInner<T> {`
`234`	`234`	`.context("couldn't create AsyncCx to block on async operation")?;`
`235`	`235`	`let future = mk_future(self);`
`236`	`236`	`let mut future = core::pin::pin!(future);`
`237`		`- unsafe { Ok(async_cx.block_on(future.as_mut(), None)?.0) }`
	`237`	`+ unsafe { Ok(async_cx.block_on(future.as_mut())?) }`
`238`	`238`	`}`
`239`	`239`	`#[cfg(not(feature = "component-model-async"))]`
`240`	`240`	`{`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ impl StoreOpaque {`
`51`	`51`	`unsafe {`
`52`	`52`	`let async_cx = crate::component::concurrent::AsyncCx::new(&mut scope);`
`53`	`53`	`let future = scope.grow_or_collect_gc_heap_async(bytes_needed);`
`54`		`- async_cx.block_on(Box::pin(future).as_mut(), None)?.0;`
	`54`	`+ async_cx.block_on(Box::pin(future).as_mut())?;`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`} else {`