Support language-specific configuration in wit-bindgen test (#1230)

This commit extends the configuration format with a `lang` field to be
able to pass things like compiler flags. To help port one of the Rust
tests I plan on adding eventual functionality for allowing Rust tests
to specify an auxiliary file to build as a crate.

Author: alexcrichton

crates/test/src/c.rs

@@ -1,7 +1,9 @@
+use crate::config::StringList;
 use crate::{Compile, Kind, LanguageMethods, Runner, Verify};
 use anyhow::Result;
 use clap::Parser;
 use heck::ToSnakeCase;
+use serde::Deserialize;
 use std::env;
 use std::path::PathBuf;
 use std::process::Command;
@@ -17,6 +19,15 @@ pub struct C;
 
 pub struct Cpp;
 
+/// C/C++-specific configuration of component files
+#[derive(Default, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct LangConfig {
+    /// Space-separated list or array of compiler flags to pass.
+    #[serde(default)]
+    cflags: StringList,
+}
+
 fn clang(runner: &Runner<'_>) -> PathBuf {
     match &runner.opts.c.wasi_sdk_path {
         Some(path) => path.join("bin/wasm32-wasip2-clang"),
@@ -124,6 +135,8 @@ fn prepare(runner: &mut Runner<'_>, compiler: PathBuf) -> Result<()> {
 }
 
 fn compile(runner: &Runner<'_>, compile: &Compile<'_>, compiler: PathBuf) -> Result<()> {
+    let config = compile.component.deserialize_lang_config::<LangConfig>()?;
+
     // Compile the C-based bindings to an object file.
     let bindings_object = compile.output.with_extension("bindings.o");
     let mut cmd = Command::new(clang(runner));
@@ -163,6 +176,9 @@ fn compile(runner: &Runner<'_>, compile: &Compile<'_>, compiler: PathBuf) -> Res
         .arg("-g")
         .arg("-o")
         .arg(&compile.output);
+    for flag in Vec::from(config.cflags) {
+        cmd.arg(flag);
+    }
     match compile.component.kind {
         Kind::Runner => {}
         Kind::Test => {

crates/test/src/config.rs

@@ -30,33 +30,49 @@ use anyhow::Context;
 use anyhow::Result;
 use serde::de::DeserializeOwned;
 use serde::Deserialize;
+use std::collections::HashMap;
 
 /// Configuration that can be placed at the top of runtime tests in source
-/// language files. This is currently language-agnostic.
+/// language files.
+///
+/// This is a union of language-agnostic and language-specific configuration.
+/// Language-agnostic configuration can be bindings generator arguments:
+///
+/// ```toml
+/// args = '--foo --bar'
+/// #  or ...
+/// args = ['--foo', '--bar']
+/// ```
+///
+/// but languages may each have their own configuration:
+///
+/// ```toml
+/// [lang]
+/// rustflags = '-O'
+/// ```
+///
+/// The `Component::deserialize_lang_config` helper is used to deserialize the
+/// `lang` field here.
 #[derive(Default, Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
-pub struct RuntimeTestConfig {
+pub struct RuntimeTestConfig<T = HashMap<String, toml::Value>> {
     /// Extra command line arguments to pass to the language-specific bindings
     /// generator.
     ///
     /// This is either a string which is whitespace delimited or it's an array
     /// of strings. By default no extra arguments are passed.
     #[serde(default)]
     pub args: StringList,
-    //
-    // Maybe add something like this eventually if necessary? For example plumb
-    // arbitrary configuration from tests to the "compile" backend. This would
-    // then thread through as `Compile` and could be used to pass compiler flags
-    // for example.
-    //
-    // lang: HashMap<String, String>,
 
-    // ...
-    //
-    // or alternatively could also have something dedicated like:
-    // compile_flags: StringList,
+    /// Language-specific configuration
     //
-    // unclear! This should be expanded on over time as necessary.
+    // Note that this is an `Option<T>` where `T` defaults to a catch-all hash
+    // map with a bunch of toml values in it. The idea here is that tests are
+    // first parsed with the `HashMap` configuration. If that's not present
+    // then the language uses its default configuration but if it is present
+    // then the fields are re-parsed where `T` is specific-per-language. The
+    // `Component::deserialize_lang_config` helper is intended for this.
+    pub lang: Option<T>,
 }
 
 #[derive(Deserialize)]

crates/test/src/lib.rs

@@ -151,6 +151,12 @@ struct Component {
     /// The WIT world that's being used with this component, loaded from
     /// `test.wit`.
     bindgen: Bindgen,
+
+    /// The contents of the test file itself.
+    contents: String,
+
+    /// The contents of the test file itself.
+    lang_config: Option<HashMap<String, toml::Value>>,
 }
 
 #[derive(Clone)]
@@ -390,6 +396,8 @@ impl Runner<'_> {
             language,
             bindgen,
             kind,
+            contents,
+            lang_config: config.lang,
         })
     }
 
@@ -1084,3 +1092,34 @@ fn write_if_different(path: &Path, contents: impl AsRef<[u8]>) -> Result<bool> {
     fs::write(path, contents).with_context(|| format!("failed to write {path:?}"))?;
     Ok(true)
 }
+
+impl Component {
+    /// Helper to convert `RuntimeTestConfig` to a `RuntimeTestConfig<T>` and
+    /// then extract the `T`.
+    ///
+    /// This is called from within each language's implementation with a
+    /// specific `T` necessary for that language.
+    fn deserialize_lang_config<T>(&self) -> Result<T>
+    where
+        T: Default + serde::de::DeserializeOwned,
+    {
+        // If this test has no language-specific configuration then return this
+        // language's default configuration.
+        if self.lang_config.is_none() {
+            return Ok(T::default());
+        }
+
+        // Otherwise re-parse the TOML at the top of the file but this time
+        // with the specific `T` that we're interested in. This is expected
+        // to then produce a value in the `lang` field since
+        // `self.lang_config.is_some()` is true.
+        let config = config::parse_test_config::<config::RuntimeTestConfig<T>>(
+            &self.contents,
+            self.language
+                .obj()
+                .comment_prefix_for_test_config()
+                .unwrap(),
+        )?;
+        Ok(config.lang.unwrap())
+    }
+}

crates/test/src/rust.rs

@@ -1,7 +1,9 @@
+use crate::config::StringList;
 use crate::{Compile, Kind, LanguageMethods, Runner, Verify};
 use anyhow::Result;
 use clap::Parser;
 use heck::ToSnakeCase;
+use serde::Deserialize;
 use std::env;
 use std::path::PathBuf;
 use std::process::Command;
@@ -30,6 +32,17 @@ pub struct State {
     wit_bindgen_deps: Vec<PathBuf>,
 }
 
+/// Rust-specific configuration of component files
+#[derive(Default, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RustConfig {
+    /// Space-separated list or array of compiler flags to pass.
+    #[serde(default)]
+    rustflags: StringList,
+    // TODO: something about auxiliary builds of crates to test cross-crate
+    // behavior.
+}
+
 impl LanguageMethods for Rust {
     fn display(&self) -> &str {
         "rust"
@@ -148,6 +161,8 @@ path = 'lib.rs'
     fn compile(&self, runner: &Runner<'_>, compile: &Compile) -> Result<()> {
         let mut cmd = runner.rustc(Edition::E2021);
 
+        let config = compile.component.deserialize_lang_config::<RustConfig>()?;
+
         // If this rust target doesn't natively produce a component then place
         // the compiler output in a temporary location which is componentized
         // later on.
@@ -168,6 +183,10 @@ path = 'lib.rs'
             .arg(&compile.component.path)
             .arg("-o")
             .arg(&output);
+        for flag in Vec::from(config.rustflags) {
+            cmd.arg(flag);
+        }
+
         match compile.component.kind {
             Kind::Runner => {}
             Kind::Test => {

tests/runtime-new/demo/runner-opt.c

@@ -0,0 +1,8 @@
+//@ [lang]
+//@ cflags = '-O'
+
+#include <runner.h>
+
+int main() {
+  a_b_the_test_x();
+}

tests/runtime-new/demo/runner-opt.rs

@@ -0,0 +1,8 @@
+//@ [lang]
+//@ rustflags = '-O'
+
+include!(env!("BINDINGS"));
+
+fn main() {
+    a::b::the_test::x();
+}