Add wstd::main and wstd::test macros for WASIp3

Author: adamrk

.cargo/config.toml

@@ -2,4 +2,4 @@
 # wasmtime is given:
 # * AWS auth environment variables, for running the wstd-aws integration tests.
 # * . directory is available at .
-runner = "wasmtime run -Shttp --env AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY --env AWS_SESSION_TOKEN --dir .::."
+runner = "wasmtime run -Sp3 -Shttp --env AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY --env AWS_SESSION_TOKEN --dir .::."

macro/src/lib.rs

@@ -2,6 +2,15 @@ use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
 use syn::{ItemFn, parse_macro_input, spanned::Spanned};
 
+fn returns_unit(output: &syn::ReturnType) -> bool {
+    match output {
+        syn::ReturnType::Default => true,
+        syn::ReturnType::Type(_, ty) => {
+            matches!(&**ty, syn::Type::Tuple(tuple) if tuple.elems.is_empty())
+        }
+    }
+}
+
 #[proc_macro_attribute]
 pub fn attr_macro_main(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as ItemFn);
@@ -84,6 +93,149 @@ pub fn attr_macro_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
     .into()
 }
 
+#[proc_macro_attribute]
+pub fn attr_macro_main_p3(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+
+    if input.sig.asyncness.is_none() {
+        return quote_spanned! { input.sig.fn_token.span()=>
+            compile_error!("fn must be `async fn`");
+        }
+        .into();
+    }
+
+    if input.sig.ident != "main" {
+        return quote_spanned! { input.sig.ident.span()=>
+            compile_error!("only `async fn main` can be used for #[wstd::main]");
+        }
+        .into();
+    }
+
+    if !input.sig.inputs.is_empty() {
+        return quote_spanned! { input.sig.inputs.span()=>
+            compile_error!("arguments to main are not supported");
+        }
+        .into();
+    }
+    let attrs = input.attrs;
+    let output = input.sig.output;
+    let block = input.block;
+    let run_result = if returns_unit(&output) {
+        quote! {
+            __run().await;
+            ::core::result::Result::Ok(())
+        }
+    } else {
+        quote! {
+            ::core::result::Result::map_err(__run().await, |_| ())
+        }
+    };
+    quote! {
+        struct __WstdCliRunner;
+
+        impl ::wstd::__internal::wasip3::exports::cli::run::Guest for __WstdCliRunner {
+            async fn run() -> ::core::result::Result<(), ()> {
+                #(#attrs)*
+                async fn __run() #output {
+                    #block
+                }
+
+                #run_result
+            }
+        }
+
+        ::wstd::__internal::wasip3::cli::command::export!(
+            __WstdCliRunner with_types_in ::wstd::__internal::wasip3
+        );
+
+        // Provide a `main` so users don't have to write `#![no_main]`.
+        fn main() {
+            ::core::unreachable!(
+                "wstd p3 components run via the wasi:cli/run@0.3.0 export, not `main`"
+            )
+        }
+    }
+    .into()
+}
+
+#[proc_macro_attribute]
+pub fn attr_macro_test_p3(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+
+    if input.sig.asyncness.is_none() {
+        return quote_spanned! { input.sig.fn_token.span()=>
+            compile_error!("fn must be `async fn`");
+        }
+        .into();
+    }
+
+    if !input.sig.inputs.is_empty() {
+        return quote_spanned! { input.sig.inputs.span()=>
+            compile_error!("arguments to a test are not supported");
+        }
+        .into();
+    }
+    let attrs = input.attrs;
+    let output = input.sig.output;
+    let block = input.block;
+    let name = input.sig.ident;
+    let message = format!("test {name} ... ");
+    let run_result = if returns_unit(&output) {
+        quote! {
+            ::std::println!("");
+            ::std::print!(#message);
+            __run().await;
+            ::std::println!("ok");
+            ::std::println!("");
+            ::core::result::Result::Ok(())
+        }
+    } else {
+        quote! {
+            ::std::println!("");
+            ::std::print!(#message);
+            match __run().await {
+                ::core::result::Result::Ok(_) => {
+                    ::std::println!("ok");
+                    ::std::println!("");
+                    ::core::result::Result::Ok(())
+                }
+                ::core::result::Result::Err(err) => {
+                    ::std::println!("failed");
+                    ::std::println!("Error {:?}", err);
+                    ::std::println!("");
+                    ::core::result::Result::Err(())
+                }
+            }
+        }
+    };
+    quote! {
+        struct __WstdCliRunner;
+
+        impl ::wstd::__internal::wasip3::exports::cli::run::Guest for __WstdCliRunner {
+            async fn run() -> ::core::result::Result<(), ()> {
+                #(#attrs)*
+                async fn __run() #output {
+                    #block
+                }
+
+                #run_result
+            }
+        }
+
+        ::wstd::__internal::wasip3::cli::command::export!(
+            __WstdCliRunner with_types_in ::wstd::__internal::wasip3
+        );
+
+        // Provide a `main` so users don't have to write `#![no_main]`.
+        fn main() {
+            ::core::unreachable!(
+                "wstd p3 components run via the wasi:cli/run@0.3.0 export, not `main`"
+            )
+        }
+    }
+    .into()
+}
+
 /// Enables a HTTP server main function, for creating [HTTP servers].
 ///
 /// [HTTP servers]: https://docs.rs/wstd/latest/wstd/http/server/index.html

src/lib.rs

@@ -87,6 +87,9 @@ pub use wstd_macro::{
     attr_macro_http_server as http_server, attr_macro_main as main, attr_macro_test as test,
 };
 
+#[cfg(p3)]
+pub use wstd_macro::{attr_macro_main_p3 as main, attr_macro_test_p3 as test};
+
 // Re-export the active WASI backend crate for use only by `wstd-macro` macros.
 // The proc macros need to generate code that uses these definitions, but we
 // don't want to treat it as part of our public API with regards to semver, so

tests/http_first_byte_timeout.rs

@@ -1,6 +1,6 @@
 use wstd::http::{Body, Client, Request, error::ErrorCode};
 
-#[wstd::main]
+#[wstd::test]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Set first byte timeout to 1/2 second.
     let mut client = Client::new();

tests/macro_main.rs

@@ -0,0 +1,6 @@
+// Verifies that the `main` macro is compiling.
+
+#[wstd::main]
+async fn main() {
+    assert_eq!(1 + 1, 2);
+}

tests/macro_test.rs

@@ -0,0 +1,7 @@
+// Verify that the test macro is acutally running.
+
+#[wstd::test]
+async fn pure_computation() -> Result<(), String> {
+    assert_eq!(1 + 1, 2);
+    Ok(())
+}