Add --async[=true|false] flag to wast CLI (#11953)

This was needed to reproduce a fuzz bug recently and seemed like a good
piece of functionality to have.

Author: alexcrichton

crates/fuzzing/src/oracles.rs

@@ -758,6 +758,7 @@ pub fn wast_test(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<()> {
     } else {
         wasmtime_wast::Async::Yes
     };
+    log::debug!("async: {async_:?}");
     let engine = Engine::new(&fuzz_config.to_wasmtime()).unwrap();
     let mut wast_context = WastContext::new(&engine, async_, move |store| {
         fuzz_config.configure_store_epoch_and_fuel(store);

crates/wast/src/wast.rs

@@ -92,7 +92,7 @@ enum Export<'a> {
 /// Whether or not to use async APIs when calling wasm during wast testing.
 ///
 /// Passed to [`WastContext::new`].
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 #[expect(missing_docs, reason = "self-describing variants")]
 pub enum Async {
     Yes,

src/commands/wast.rs

@@ -31,25 +31,41 @@ pub struct WastCommand {
     /// compiling natively.
     #[arg(long)]
     precompile_load: Option<PathBuf>,
+
+    /// Whether or not to run wasm in async mode.
+    ///
+    /// This is enabled by default but disabling it may be useful when testing
+    /// Wasmtime itself.
+    #[arg(long = "async", require_equals = true, value_name = "true|false")]
+    async_: Option<Option<bool>>,
 }
 
 impl WastCommand {
     /// Executes the command.
     pub fn execute(mut self) -> Result<()> {
         self.common.init_logging()?;
 
+        let async_ = optional_flag_with_default(self.async_, true);
         let mut config = self.common.config(None)?;
-        config.async_support(true);
+        config.async_support(async_);
         let engine = Engine::new(&config)?;
-        let mut wast_context = WastContext::new(&engine, wasmtime_wast::Async::Yes, move |store| {
-            if let Some(fuel) = self.common.wasm.fuel {
-                store.set_fuel(fuel).unwrap();
-            }
-            if let Some(true) = self.common.wasm.epoch_interruption {
-                store.epoch_deadline_trap();
-                store.set_epoch_deadline(1);
-            }
-        });
+        let mut wast_context = WastContext::new(
+            &engine,
+            if async_ {
+                wasmtime_wast::Async::Yes
+            } else {
+                wasmtime_wast::Async::No
+            },
+            move |store| {
+                if let Some(fuel) = self.common.wasm.fuel {
+                    store.set_fuel(fuel).unwrap();
+                }
+                if let Some(true) = self.common.wasm.epoch_interruption {
+                    store.epoch_deadline_trap();
+                    store.set_epoch_deadline(1);
+                }
+            },
+        );
 
         wast_context.generate_dwarf(optional_flag_with_default(self.generate_dwarf, true));
         wast_context