Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

11.6 KB
Raw Blame
//! Wasmtime test macro.
//!
//! This macro is a helper to define tests that exercise multiple configuration
//! combinations for Wasmtime. Currently compiler strategies, garbage
//! collectors, and wasm features are supported.
//!
//! Usage
//!
//! To exclude a compiler strategy:
//!
//! ```rust
//! #[wasmtime_test(strategies(not(Winch)))]
//! fn my_test(config: &mut Config) -> Result<()> {
//!    Ok(())
//! }
//! ```
//!
//! To use just one specific compiler strategy:
//!
//! ```rust
//! #[wasmtime_test(strategies(only(Winch)))]
//! fn my_test(config: &mut Config) -> Result<()> {
//!     Ok(())
//! }
//! ```
//!
//! To use specific garbage collectors:
//!
//! ```rust
//! #[wasmtime_test(collectors(Null, DeferredReferenceCounting))]
//! fn my_test(config: &mut Config) -> Result<()> {
//!     Ok(())
//! }
//! ```
//!
//! Use `collectors(All)` to test all concrete garbage collectors.
//!
//! To explicitly indicate that a wasm feature is needed:
//! ```
//! #[wasmtime_test(wasm_features(gc))]
//! fn my_wasm_gc_test(config: &mut Config) -> Result<()> {
//!   Ok(())
//! }
//! ```
//!
//! If the specified wasm feature is disabled by default, the macro will enable
//! the feature in the configuration passed to the test.
//!
//! If the wasm feature is not supported by any of the compiler strategies, no
//! tests will be generated for such strategy.
use proc_macro::TokenStream;
use quote::{ToTokens, TokenStreamExt, quote};
use syn::{
    Attribute, Ident, Result, ReturnType, Signature, Visibility, braced,
    meta::ParseNestedMeta,
    parse::{Parse, ParseStream},
    parse_macro_input, token,
};
use wasmtime_test_util::wast::{Collector, Compiler};

/// Test configuration.
struct TestConfig {
    strategies: Vec<Compiler>,
    collectors: Vec<Collector>,
    flags: wasmtime_test_util::wast::TestConfig,
}

impl TestConfig {
    fn strategies_from(&mut self, meta: &ParseNestedMeta) -> Result<()> {
        meta.parse_nested_meta(|meta| {
            if meta.path.is_ident("not") {
                meta.parse_nested_meta(|meta| {
                    if meta.path.is_ident("Winch") {
                        self.strategies.retain(|s| *s != Compiler::Winch);
                        Ok(())
                    } else if meta.path.is_ident("CraneliftNative") {
                        self.strategies.retain(|s| *s != Compiler::CraneliftNative);
                        Ok(())
                    } else if meta.path.is_ident("CraneliftPulley") {
                        self.strategies.retain(|s| *s != Compiler::CraneliftPulley);
                        Ok(())
                    } else {
                        Err(meta.error("Unknown strategy"))
                    }
                })
            } else if meta.path.is_ident("only") {
                meta.parse_nested_meta(|meta| {
                    if meta.path.is_ident("Winch") {
                        self.strategies.retain(|s| *s == Compiler::Winch);
                        Ok(())
                    } else if meta.path.is_ident("CraneliftNative") {
                        self.strategies.retain(|s| *s == Compiler::CraneliftNative);
                        Ok(())
                    } else if meta.path.is_ident("CraneliftPulley") {
                        self.strategies.retain(|s| *s == Compiler::CraneliftPulley);
                        Ok(())
                    } else {
                        Err(meta.error("Unknown strategy"))
                    }
                })
            } else {
                Err(meta.error("Unknown identifier"))
            }
        })?;

        if self.strategies.len() == 0 {
            Err(meta.error("Expected at least one strategy"))
        } else {
            Ok(())
        }
    }

    fn wasm_features_from(&mut self, meta: &ParseNestedMeta) -> Result<()> {
        meta.parse_nested_meta(|meta| {
            for (feature, enabled) in self.flags.options_mut() {
                if meta.path.is_ident(feature) {
                    *enabled = Some(true);
                    return Ok(());
                }
            }
            Err(meta.error("Unsupported test feature"))
        })?;

        Ok(())
    }

    fn collectors_from(&mut self, meta: &ParseNestedMeta) -> Result<()> {
        let mut collectors = Vec::new();
        meta.parse_nested_meta(|meta| {
            if meta.path.is_ident("All") {
                if !collectors.is_empty() {
                    return Err(meta.error("`All` cannot be combined with other collectors"));
                }
                collectors.extend([
                    Collector::Null,
                    Collector::Copying,
                    Collector::DeferredReferenceCounting,
                ]);
                return Ok(());
            }

            let collector = if meta.path.is_ident("Auto") {
                Collector::Auto
            } else if meta.path.is_ident("Null") {
                Collector::Null
            } else if meta.path.is_ident("DeferredReferenceCounting") {
                Collector::DeferredReferenceCounting
            } else if meta.path.is_ident("Copying") {
                Collector::Copying
            } else {
                return Err(meta.error("Unknown collector"));
            };

            if collector == Collector::Auto && !collectors.is_empty()
                || collector != Collector::Auto && collectors.contains(&Collector::Auto)
            {
                return Err(meta.error("`Auto` cannot be combined with other collectors"));
            }
            if collectors.contains(&collector) {
                return Err(meta.error("Duplicate collector"));
            }
            collectors.push(collector);
            Ok(())
        })?;

        if collectors.is_empty() {
            return Err(meta.error("Expected at least one collector"));
        }
        self.collectors = collectors;
        Ok(())
    }
}

impl Default for TestConfig {
    fn default() -> Self {
        Self {
            strategies: vec![
                Compiler::CraneliftNative,
                Compiler::Winch,
                Compiler::CraneliftPulley,
            ],
            collectors: vec![Collector::Auto],
            flags: Default::default(),
        }
    }
}

/// A generic function body represented as a braced [`TokenStream`].
struct Block {
    brace: token::Brace,
    rest: proc_macro2::TokenStream,
}

impl Parse for Block {
    fn parse(input: ParseStream) -> Result<Self> {
        let content;
        Ok(Self {
            brace: braced!(content in input),
            rest: content.parse()?,
        })
    }
}

impl ToTokens for Block {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        self.brace.surround(tokens, |tokens| {
            tokens.append_all(self.rest.clone());
        });
    }
}

/// Custom function parser.
/// Parses the function's attributes, visibility and signature, leaving the
/// block as an opaque [`TokenStream`].
struct Fn {
    attrs: Vec<Attribute>,
    visibility: Visibility,
    sig: Signature,
    body: Block,
}

impl Parse for Fn {
    fn parse(input: ParseStream) -> Result<Self> {
        let attrs = input.call(Attribute::parse_outer)?;
        let visibility: Visibility = input.parse()?;
        let sig: Signature = input.parse()?;
        let body: Block = input.parse()?;

        Ok(Self {
            attrs,
            visibility,
            sig,
            body,
        })
    }
}

impl ToTokens for Fn {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        for attr in &self.attrs {
            attr.to_tokens(tokens);
        }
        self.visibility.to_tokens(tokens);
        self.sig.to_tokens(tokens);
        self.body.to_tokens(tokens);
    }
}

pub fn run(attrs: TokenStream, item: TokenStream) -> TokenStream {
    let mut test_config = TestConfig::default();

    let config_parser = syn::meta::parser(|meta| {
        if meta.path.is_ident("strategies") {
            test_config.strategies_from(&meta)
        } else if meta.path.is_ident("collectors") {
            test_config.collectors_from(&meta)
        } else if meta.path.is_ident("wasm_features") {
            test_config.wasm_features_from(&meta)
        } else {
            Err(meta.error("Unsupported attributes"))
        }
    });

    parse_macro_input!(attrs with config_parser);

    match expand(&test_config, parse_macro_input!(item as Fn)) {
        Ok(tok) => tok,
        Err(e) => e.into_compile_error().into(),
    }
}

fn expand(test_config: &TestConfig, func: Fn) -> Result<TokenStream> {
    let mut tests = vec![quote! { #func }];
    let attrs = &func.attrs;
    let func_name = &func.sig.ident;

    match &func.sig.output {
        ReturnType::Default => {
            return Err(syn::Error::new(func_name.span(), "Expected `Result<()>`"));
        }
        ReturnType::Type(..) => {}
    };

    let test_attr = if func.sig.asyncness.is_some() {
        quote! { #[tokio::test] }
    } else {
        quote! { #[test] }
    };

    for strategy in &test_config.strategies {
        let strategy_name = format!("{strategy:?}");
        let (asyncness, await_) = if func.sig.asyncness.is_some() {
            (quote! { async }, quote! { .await })
        } else {
            (quote! {}, quote! {})
        };

        // Ignore non-pulley tests in Miri as that's the only compiler which
        // works in Miri.
        let ignore_miri = match strategy {
            Compiler::CraneliftPulley => quote!(),
            _ => quote!(#[cfg_attr(miri, ignore)]),
        };

        let flags = format!("wasmtime_test_util::wast::{:?}", test_config.flags)
            .parse::<proc_macro2::TokenStream>()
            .unwrap();
        let strategy_ident = quote::format_ident!("{strategy_name}");

        for collector in &test_config.collectors {
            let collector_name = format!("{collector:?}");
            let collector_ident = quote::format_ident!("{collector_name}");
            let collector_suffix = match collector {
                Collector::Auto => None,
                Collector::Null => Some("null"),
                Collector::DeferredReferenceCounting => Some("drc"),
                Collector::Copying => Some("copying"),
            };
            let test_name = match collector_suffix {
                Some(collector) => format!(
                    "{}_{}_{}",
                    strategy_name.to_lowercase(),
                    collector,
                    func_name
                ),
                None => format!("{}_{}", strategy_name.to_lowercase(), func_name),
            };
            let test_name = Ident::new(&test_name, func_name.span());

            let tok = quote! {
                #test_attr
                #(#attrs)*
                #ignore_miri
                #asyncness fn #test_name() {
                    // Skip this test completely if the compiler doesn't support
                    // this host.
                    let compiler = wasmtime_test_util::wast::Compiler::#strategy_ident;
                    if !compiler.supports_host() {
                        return;
                    }
                    let _ = env_logger::try_init();
                    let mut opts = compiler.common_options();
                    opts.codegen.collector = Some(wasmtime::Collector::#collector_ident);
                    #flags.apply(&mut opts).unwrap();
                    let mut config: Config = opts.config(None).unwrap();
                    let result = #func_name(&mut config) #await_;
                    if compiler.should_fail(&#flags) {
                        assert!(result.is_err());
                    } else {
                        result.unwrap();
                    }
                }
            };

            tests.push(tok);
        }
    }
    Ok(quote! {
        #(#tests)*
    }
    .into())
}