wiggle: convenient syntax for marking all funcs async

crates/wiggle/generate/src/config.rs

@@ -47,7 +47,9 @@ impl Parse for ConfigField {
         } else if lookahead.peek(Token![async]) {
             input.parse::<Token![async]>()?;
             input.parse::<Token![:]>()?;
-            Ok(ConfigField::Async(input.parse()?))
+            Ok(ConfigField::Async(AsyncConf {
+                functions: input.parse()?,
+            }))
         } else {
             Err(lookahead.error())
         }
@@ -282,40 +284,62 @@ impl Parse for ErrorConfField {
 #[derive(Clone, Default, Debug)]
 /// Modules and funcs that have async signatures
 pub struct AsyncConf {
-    functions: HashMap<String, Vec<String>>,
+    functions: AsyncFunctions,
+}
+
+#[derive(Clone, Debug)]
+pub enum AsyncFunctions {
+    Some(HashMap<String, Vec<String>>),
+    All,
+}
+impl Default for AsyncFunctions {
+    fn default() -> Self {
+        AsyncFunctions::Some(HashMap::default())
+    }
 }
 
 impl AsyncConf {
     pub fn is_async(&self, module: &str, function: &str) -> bool {
-        self.functions
+        match &self.functions {
-            .get(module)
+            AsyncFunctions::Some(fs) => fs
-            .and_then(|fs| fs.iter().find(|f| *f == function))
+                .get(module)
-            .is_some()
+                .and_then(|fs| fs.iter().find(|f| *f == function))
+                .is_some(),
+            AsyncFunctions::All => true,
+        }
     }
 }
 
-impl Parse for AsyncConf {
+impl Parse for AsyncFunctions {
     fn parse(input: ParseStream) -> Result<Self> {
         let content;
-        let _ = braced!(content in input);
+        let lookahead = input.lookahead1();
-        let items: Punctuated<AsyncConfField, Token![,]> =
+        if lookahead.peek(syn::token::Brace) {
-            content.parse_terminated(Parse::parse)?;
+            let _ = braced!(content in input);
-        let mut functions: HashMap<String, Vec<String>> = HashMap::new();
+            let items: Punctuated<AsyncConfField, Token![,]> =
-        use std::collections::hash_map::Entry;
+                content.parse_terminated(Parse::parse)?;
-        for i in items {
+            let mut functions: HashMap<String, Vec<String>> = HashMap::new();
-            let function_names = i
+            use std::collections::hash_map::Entry;
-                .function_names
+            for i in items {
-                .iter()
+                let function_names = i
-                .map(|i| i.to_string())
+                    .function_names
-                .collect::<Vec<String>>();
+                    .iter()
-            match functions.entry(i.module_name.to_string()) {
+                    .map(|i| i.to_string())
-                Entry::Occupied(o) => o.into_mut().extend(function_names),
+                    .collect::<Vec<String>>();
-                Entry::Vacant(v) => {
+                match functions.entry(i.module_name.to_string()) {
-                    v.insert(function_names);
+                    Entry::Occupied(o) => o.into_mut().extend(function_names),
+                    Entry::Vacant(v) => {
+                        v.insert(function_names);
+                    }
                 }
             }
+            Ok(AsyncFunctions::Some(functions))
+        } else if lookahead.peek(Token![*]) {
+            let _: Token![*] = input.parse().unwrap();
+            Ok(AsyncFunctions::All)
+        } else {
+            Err(lookahead.error())
         }
-        Ok(AsyncConf { functions })
     }
 }
 

crates/wiggle/tests/atoms_async.rs

@@ -7,9 +7,7 @@ use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 wiggle::from_witx!({
     witx: ["$CARGO_MANIFEST_DIR/tests/atoms.witx"],
-    async: {
+    async: *,
-        atoms::{int_float_args, double_int_return_float}
-    }
 });
 
 impl_errno!(types::Errno);

crates/wiggle/wasmtime/macro/src/config.rs

@@ -1,4 +1,4 @@
-use wiggle_generate::config::AsyncConfField;
+use wiggle_generate::config::AsyncFunctions;
 use {
     proc_macro2::Span,
     std::collections::HashMap,
@@ -66,13 +66,17 @@ impl Parse for ConfigField {
         } else if lookahead.peek(Token![async]) {
             input.parse::<Token![async]>()?;
             input.parse::<Token![:]>()?;
-            Ok(ConfigField::Async(input.parse()?))
+            Ok(ConfigField::Async(AsyncConf {
+                blocking: false,
+                functions: input.parse()?,
+            }))
         } else if lookahead.peek(kw::block_on) {
             input.parse::<kw::block_on>()?;
             input.parse::<Token![:]>()?;
-            let mut async_conf: AsyncConf = input.parse()?;
+            Ok(ConfigField::Async(AsyncConf {
-            async_conf.blocking = true;
+                blocking: true,
-            Ok(ConfigField::Async(async_conf))
+                functions: input.parse()?,
+            }))
         } else {
             Err(lookahead.error())
         }
@@ -273,7 +277,7 @@ impl Parse for ModulesConf {
 /// Modules and funcs that have async signatures
 pub struct AsyncConf {
     blocking: bool,
-    functions: HashMap<String, Vec<String>>,
+    functions: AsyncFunctions,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -297,47 +301,24 @@ impl Asyncness {
 
 impl AsyncConf {
     pub fn is_async(&self, module: &str, function: &str) -> Asyncness {
-        if self
+        let a = if self.blocking {
-            .functions
+            Asyncness::Blocking
-            .get(module)
-            .and_then(|fs| fs.iter().find(|f| *f == function))
-            .is_some()
-        {
-            if self.blocking {
-                Asyncness::Blocking
-            } else {
-                Asyncness::Async
-            }
         } else {
-            Asyncness::Sync
+            Asyncness::Async
-        }
+        };
-    }
+        match &self.functions {
-}
+            AsyncFunctions::Some(fs) => {
-
+                if fs
-impl Parse for AsyncConf {
+                    .get(module)
-    fn parse(input: ParseStream) -> Result<Self> {
+                    .and_then(|fs| fs.iter().find(|f| *f == function))
-        let content;
+                    .is_some()
-        let _ = braced!(content in input);
+                {
-        let items: Punctuated<AsyncConfField, Token![,]> =
+                    a
-            content.parse_terminated(Parse::parse)?;
+                } else {
-        let mut functions: HashMap<String, Vec<String>> = HashMap::new();
+                    Asyncness::Sync
-        use std::collections::hash_map::Entry;
-        for i in items {
-            let function_names = i
-                .function_names
-                .iter()
-                .map(|i| i.to_string())
-                .collect::<Vec<String>>();
-            match functions.entry(i.module_name.to_string()) {
-                Entry::Occupied(o) => o.into_mut().extend(function_names),
-                Entry::Vacant(v) => {
-                    v.insert(function_names);
                 }
             }
+            AsyncFunctions::All => a,
         }
-        Ok(AsyncConf {
-            functions,
-            blocking: false,
-        })
     }
 }