Merge pull request #1524 from RReverser/wasi

Support arbitrary targets

Author: drager

src/bindgen.rs

@@ -12,6 +12,7 @@ use std::process::Command;
 /// Run the `wasm-bindgen` CLI to generate bindings for the current crate's
 /// `.wasm`.
 pub fn wasm_bindgen_build(
+    wasm_path: &str,
     data: &CrateData,
     install_status: &install::Status,
     out_dir: &Path,
@@ -21,31 +22,9 @@ pub fn wasm_bindgen_build(
     reference_types: bool,
     target: Target,
     profile: BuildProfile,
-    extra_options: &Vec<String>,
 ) -> Result<()> {
-    let profile_name = match profile.clone() {
-        BuildProfile::Release | BuildProfile::Profiling => "release",
-        BuildProfile::Dev => "debug",
-        BuildProfile::Custom(profile_name) => &profile_name.clone(),
-    };
-
     let out_dir = out_dir.to_str().unwrap();
 
-    let target_directory = {
-        let mut has_target_dir_iter = extra_options.iter();
-        has_target_dir_iter
-            .find(|&it| it == "--target-dir")
-            .and_then(|_| has_target_dir_iter.next())
-            .map(Path::new)
-            .unwrap_or(data.target_directory())
-    };
-
-    let wasm_path = target_directory
-        .join("wasm32-unknown-unknown")
-        .join(profile_name)
-        .join(data.crate_name())
-        .with_extension("wasm");
-
     let dts_arg = if disable_dts {
         "--no-typescript"
     } else {

src/build/mod.rs

@@ -6,8 +6,10 @@ use crate::emoji;
 use crate::manifest::Crate;
 use crate::PBAR;
 use anyhow::{anyhow, bail, Context, Result};
+use cargo_metadata::Message;
+use std::io::BufReader;
 use std::path::Path;
-use std::process::Command;
+use std::process::{Command, Stdio};
 use std::str;
 
 pub mod wasm_target;
@@ -72,12 +74,12 @@ fn wasm_pack_local_version() -> Option<String> {
     Some(output.to_string())
 }
 
-/// Run `cargo build` targetting `wasm32-unknown-unknown`.
+/// Run `cargo build` for Wasm with config derived from the given `BuildProfile`.
 pub fn cargo_build_wasm(
     path: &Path,
     profile: BuildProfile,
     extra_options: &[String],
-) -> Result<()> {
+) -> Result<String> {
     let msg = format!("{}Compiling to Wasm...", emoji::CYCLONE);
     PBAR.info(&msg);
 
@@ -109,7 +111,9 @@ pub fn cargo_build_wasm(
         }
     }
 
-    cmd.arg("--target").arg("wasm32-unknown-unknown");
+    // If user has specified a custom --target in Cargo options, we shouldn't override it.
+    // Otherwise, default to wasm32-unknown-unknown.
+    cmd.env("CARGO_BUILD_TARGET", "wasm32-unknown-unknown");
 
     // The `cargo` command is executed inside the directory at `path`, so relative paths set via extra options won't work.
     // To remedy the situation, all detected paths are converted to absolute paths.
@@ -132,8 +136,47 @@ pub fn cargo_build_wasm(
         .collect::<Result<Vec<_>>>()?;
     cmd.args(extra_options_with_absolute_paths);
 
-    child::run(cmd, "cargo build").context("Compiling your crate to WebAssembly failed")?;
-    Ok(())
+    cmd.arg("--message-format=json");
+
+    let mut cargo_process = cmd.stdout(Stdio::piped()).spawn()?;
+
+    let final_artifact =
+        Message::parse_stream(BufReader::new(cargo_process.stdout.as_mut().unwrap()))
+            .filter_map(|msg| {
+                match msg {
+                    Ok(Message::CompilerArtifact(artifact)) => return Some(artifact),
+                    Ok(Message::CompilerMessage(msg)) => eprintln!("{msg}"),
+                    Ok(Message::TextLine(text)) => eprintln!("{text}"),
+                    Err(err) => log::error!("Couldn't parse cargo message: {err}"),
+                    _ => {} // ignore messages irrelevant to the user
+                }
+                None
+            })
+            .last();
+
+    if !cargo_process
+        .wait()
+        .context("Failed to wait for cargo build process")?
+        .success()
+    {
+        bail!("`cargo build` failed, see the output above for details");
+    }
+
+    let wasm_files: Vec<_> = final_artifact
+        .context("Expected at least one compiler artifact in the output of `cargo build`")?
+        .filenames
+        .into_iter()
+        .filter(|path| path.extension() == Some("wasm"))
+        .collect();
+
+    match <[_; 1]>::try_from(wasm_files) {
+        Ok([filename]) => Ok(filename.into_string()),
+        Err(filenames) => {
+            bail!(
+                "Expected exactly one .wasm file in the compiler artifact, but found {filenames:?}"
+            )
+        }
+    }
 }
 
 /// Runs `cargo build --tests` targeting `wasm32-unknown-unknown`.
@@ -162,7 +205,7 @@ pub fn cargo_build_wasm_tests(path: &Path, debug: bool, extra_options: &[String]
         cmd.arg("--release");
     }
 
-    cmd.arg("--target").arg("wasm32-unknown-unknown");
+    cmd.env("CARGO_BUILD_TARGET", "wasm32-unknown-unknown");
 
     cmd.args(extra_options);
 

src/build/wasm_target.rs

@@ -10,28 +10,27 @@ use std::fmt;
 use std::path::PathBuf;
 use std::process::Command;
 
-struct Wasm32Check {
+struct Wasm32Check<'target> {
+    target: &'target str,
     rustc_path: PathBuf,
     sysroot: PathBuf,
     found: bool,
     is_rustup: bool,
 }
 
-impl fmt::Display for Wasm32Check {
+impl fmt::Display for Wasm32Check<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let target = "wasm32-unknown-unknown";
-
         if !self.found {
             let rustup_string = if self.is_rustup {
                 "It looks like Rustup is being used.".to_owned()
             } else {
-                format!("It looks like Rustup is not being used. For non-Rustup setups, the {} target needs to be installed manually. See https://drager.github.io/wasm-pack/book/prerequisites/non-rustup-setups.html on how to do this.", target)
+                format!("It looks like Rustup is not being used. For non-Rustup setups, the {} target needs to be installed manually. See https://drager.github.io/wasm-pack/book/prerequisites/non-rustup-setups.html on how to do this.", self.target)
             };
 
             writeln!(
                 f,
                 "{} target not found in sysroot: {:?}",
-                target, self.sysroot
+                self.target, self.sysroot
             )
             .and_then(|_| {
                 writeln!(
@@ -51,14 +50,14 @@ impl fmt::Display for Wasm32Check {
     }
 }
 
-/// Ensure that `rustup` has the `wasm32-unknown-unknown` target installed for
+/// Ensure that `rustup` has the requested target installed for
 /// current toolchain
-pub fn check_for_wasm32_target() -> Result<()> {
+pub fn check_for_wasm_target(target: &str) -> Result<()> {
     let msg = format!("{}Checking for the Wasm target...", emoji::TARGET);
     PBAR.info(&msg);
 
     // Check if wasm32 target is present, otherwise bail.
-    match check_wasm32_target() {
+    match check_target(target) {
         Ok(ref wasm32_check) if wasm32_check.found => Ok(()),
         Ok(wasm32_check) => bail!("{}", wasm32_check),
         Err(err) => Err(err),
@@ -81,43 +80,32 @@ fn get_rustc_sysroot() -> Result<PathBuf> {
     }
 }
 
-/// Get wasm32-unknown-unknown target libdir
-fn get_rustc_wasm32_unknown_unknown_target_libdir() -> Result<PathBuf> {
+/// Get target libdir
+fn get_rustc_target_libdir(target: &str) -> Result<PathBuf> {
     let command = Command::new("rustc")
-        .args(&[
-            "--target",
-            "wasm32-unknown-unknown",
-            "--print",
-            "target-libdir",
-        ])
+        .args(&["--target", target, "--print", "target-libdir"])
         .output()?;
 
     if command.status.success() {
         Ok(String::from_utf8(command.stdout)?.trim().into())
     } else {
         Err(anyhow!(
-            "Getting rustc's wasm32-unknown-unknown target wasn't successful. Got {}",
+            "Getting rustc's {target} target wasn't successful. Got {}",
             command.status
         ))
     }
 }
 
-fn does_wasm32_target_libdir_exist() -> bool {
-    let result = get_rustc_wasm32_unknown_unknown_target_libdir();
+fn does_target_libdir_exist(target: &str) -> bool {
+    let result = get_rustc_target_libdir(target);
 
     match result {
-        Ok(wasm32_target_libdir_path) => {
-            if wasm32_target_libdir_path.exists() {
-                info!(
-                    "Found wasm32-unknown-unknown in {:?}",
-                    wasm32_target_libdir_path
-                );
+        Ok(target_libdir_path) => {
+            if target_libdir_path.exists() {
+                info!("Found {target} in {:?}", target_libdir_path);
                 true
             } else {
-                info!(
-                    "Failed to find wasm32-unknown-unknown in {:?}",
-                    wasm32_target_libdir_path
-                );
+                info!("Failed to find {target} in {:?}", target_libdir_path);
                 false
             }
         }
@@ -128,12 +116,13 @@ fn does_wasm32_target_libdir_exist() -> bool {
     }
 }
 
-fn check_wasm32_target() -> Result<Wasm32Check> {
+fn check_target(target: &'_ str) -> Result<Wasm32Check<'_>> {
     let sysroot = get_rustc_sysroot()?;
     let rustc_path = which::which("rustc")?;
 
-    if does_wasm32_target_libdir_exist() {
+    if does_target_libdir_exist(target) {
         Ok(Wasm32Check {
+            target,
             rustc_path,
             sysroot,
             found: true,
@@ -142,16 +131,18 @@ fn check_wasm32_target() -> Result<Wasm32Check> {
     // If it doesn't exist, then we need to check if we're using rustup.
     } else {
         // If sysroot contains "rustup", then we can assume we're using rustup
-        // and use rustup to add the wasm32-unknown-unknown target.
+        // and use rustup to add the requested target.
         if sysroot.to_string_lossy().contains("rustup") {
-            rustup_add_wasm_target().map(|()| Wasm32Check {
+            rustup_add_wasm_target(target).map(|()| Wasm32Check {
+                target,
                 rustc_path,
                 sysroot,
                 found: true,
                 is_rustup: true,
             })
         } else {
             Ok(Wasm32Check {
+                target,
                 rustc_path,
                 sysroot,
                 found: false,
@@ -161,11 +152,11 @@ fn check_wasm32_target() -> Result<Wasm32Check> {
     }
 }
 
-/// Add wasm32-unknown-unknown using `rustup`.
-fn rustup_add_wasm_target() -> Result<()> {
+/// Add target using `rustup`.
+fn rustup_add_wasm_target(target: &str) -> Result<()> {
     let mut cmd = Command::new("rustup");
-    cmd.arg("target").arg("add").arg("wasm32-unknown-unknown");
-    child::run(cmd, "rustup").context("Adding the wasm32-unknown-unknown target with rustup")?;
+    cmd.arg("target").arg("add").arg(target);
+    child::run(cmd, "rustup").with_context(|| format!("Adding the {target} target with rustup"))?;
 
     Ok(())
 }

src/child.rs

@@ -3,7 +3,6 @@
 //! This module helps us ensure that all child processes that we spawn get
 //! properly logged and their output is logged as well.
 
-use crate::install::Tool;
 use anyhow::{bail, Result};
 use log::info;
 use std::process::{Command, Stdio};
@@ -43,7 +42,10 @@ pub fn run(mut command: Command, command_name: &str) -> Result<()> {
 }
 
 /// Run the given command and return its stdout.
-pub fn run_capture_stdout(mut command: Command, command_name: &Tool) -> Result<String> {
+pub fn run_capture_stdout(
+    mut command: Command,
+    command_name: impl std::fmt::Display,
+) -> Result<String> {
     info!("Running {:?}", command);
 
     let output = command