Bind more options to ComponentEncoder (#59)

* Bind more options to `ComponentEncoder`

Add `--reject-legacy-names` and `--realloc-via-memory-grow`.

* Bump action dependency

* Always pipe stdout

Author: alexcrichton

.github/workflows/main.yml

@@ -47,7 +47,7 @@ jobs:
       if: matrix.target != ''
     - run: $CENTOS cargo build --release
     - run: ./ci/build-tarballs.sh "${{ matrix.build }}" "${{ matrix.target }}"
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         name: bins-${{ matrix.build }}
         path: dist

src/lib.rs

@@ -275,6 +275,27 @@ struct ComponentLdArgs {
     #[clap(long = "adapt", value_name = "[NAME=]MODULE", value_parser = parse_adapter)]
     adapters: Vec<(String, Vec<u8>)>,
 
+    /// Whether or not "legacy" names are rejected during componentization.
+    ///
+    /// This option can be used to require the naming scheme outlined in
+    /// <https://github.com/WebAssembly/component-model/pull/378> to be used
+    /// and rejects all modules using the previous ad-hoc naming scheme.
+    ///
+    /// This defaults to `false`.
+    #[clap(long)]
+    reject_legacy_names: bool,
+
+    /// Whether or not the `cabi_realloc` function used by the adapter is backed
+    /// by `memory.grow`.
+    ///
+    /// By default the adapter will import `cabi_realloc` from the main module
+    /// and use that, but this can be used to instead back memory allocation
+    /// requests with `memory.grow` instead.
+    ///
+    /// This defaults to `false`.
+    #[clap(long)]
+    realloc_via_memory_grow: bool,
+
     /// WIT file representing additional component type information to use.
     ///
     /// May be specified more than once.
@@ -624,7 +645,9 @@ impl App {
             )?;
         }
 
-        let mut encoder = wit_component::ComponentEncoder::default();
+        let mut encoder = wit_component::ComponentEncoder::default()
+            .reject_legacy_names(self.component.reject_legacy_names)
+            .realloc_via_memory_grow(self.component.realloc_via_memory_grow);
         if let Some(validate) = self.component.validate_component {
             encoder = encoder.validate(validate);
         }

tests/all.rs

@@ -1,6 +1,7 @@
+use anyhow::{bail, Context, Result};
 use std::env;
 use std::fs;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::process::{Command, Stdio};
 
 fn compile(args: &[&str], src: &str) -> Vec<u8> {
@@ -22,11 +23,16 @@ impl Project {
     }
 
     fn compile(&self, args: &[&str], src: &str) -> Vec<u8> {
+        self.try_compile(args, src, true).unwrap()
+    }
+
+    fn try_compile(&self, args: &[&str], src: &str, inherit_stderr: bool) -> Result<Vec<u8>> {
         let mut myself = env::current_exe().unwrap();
         myself.pop(); // exe name
         myself.pop(); // 'deps'
         myself.push("wasm-component-ld");
-        let mut rustc = Command::new("rustc")
+        let mut rustc = Command::new("rustc");
+        rustc
             .arg("--target")
             .arg("wasm32-wasip1")
             .arg("-")
@@ -35,22 +41,40 @@ impl Project {
             .arg("-C")
             .arg(&format!("linker={}", myself.to_str().unwrap()))
             .args(args)
-            .current_dir(self.tempdir.path())
-            .stdout(Stdio::piped())
             .stdin(Stdio::piped())
-            .spawn()
-            .expect("failed to spawn rustc");
+            .stdout(Stdio::piped())
+            .current_dir(self.tempdir.path());
+        if !inherit_stderr {
+            rustc.stderr(Stdio::piped());
+        }
+        let mut rustc = rustc.spawn().context("failed to spawn rustc")?;
 
         rustc
             .stdin
             .take()
-            .unwrap()
+            .context("stdin should be present")?
             .write_all(src.as_bytes())
-            .unwrap();
-        let mut ret = Vec::new();
-        rustc.stdout.take().unwrap().read_to_end(&mut ret).unwrap();
-        assert!(rustc.wait().unwrap().success());
-        ret
+            .context("failed to write stdin")?;
+        let output = rustc
+            .wait_with_output()
+            .context("failed to wait for subprocess")?;
+        if !output.status.success() {
+            let mut error = format!("subprocess failed: {:?}", output.status);
+            if !output.stdout.is_empty() {
+                error.push_str(&format!(
+                    "\nstdout: {}",
+                    String::from_utf8_lossy(&output.stdout)
+                ));
+            }
+            if !output.stderr.is_empty() {
+                error.push_str(&format!(
+                    "\nstderr: {}",
+                    String::from_utf8_lossy(&output.stderr)
+                ));
+            }
+            bail!("{error}")
+        }
+        Ok(output.stdout)
     }
 }
 
@@ -227,3 +251,35 @@ fn rustc_using_argfile() {
     let output = p.compile(&["-Ccodegen-units=1000", "-Clink-arg=@args"], &src);
     assert_module(&output);
 }
+
+#[test]
+fn hello_world_with_realloc_as_memory_grow() {
+    let output = compile(
+        &["-Clink-arg=--realloc-via-memory-grow"],
+        r#"
+fn main() {
+    println!("hello!");
+}
+"#,
+    );
+    assert_component(&output);
+}
+
+// The adapter uses legacy names, so this option will always result in an error
+// right now.
+#[test]
+fn legacy_names_currently_required() {
+    let result = Project::new().try_compile(
+        &["-Clink-arg=--reject-legacy-names"],
+        r#"
+fn main() {
+    println!("hello!");
+}
+"#,
+        false,
+    );
+    let err = result.unwrap_err();
+    let err = format!("{err:?}");
+    println!("error: {err}");
+    assert!(err.contains("unknown or invalid component model import syntax"));
+}