Rework support library API

- Use builders as thin wrappers around `Command`.
- Remove dependency on `shell_words` since it is no longer needed.

Author: jieyouxu

Cargo.lock

@@ -3316,9 +3316,6 @@ dependencies = [
 [[package]]
 name = "run_make_support"
 version = "0.0.0"
-dependencies = [
- "shell-words",
-]
 
 [[package]]
 name = "rust-demangler"
@@ -5032,12 +5029,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "45bb67a18fa91266cc7807181f62f9178a6873bfad7dc788c42e6430db40184f"
 
-[[package]]
-name = "shell-words"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
-
 [[package]]
 name = "shlex"
 version = "1.3.0"

src/tools/run-make-support/Cargo.toml

@@ -4,4 +4,3 @@ version = "0.0.0"
 edition = "2021"
 
 [dependencies]
-shell-words = "1.1"

src/tools/run-make-support/src/lib.rs

@@ -2,28 +2,14 @@ use std::env;
 use std::path::PathBuf;
 use std::process::{Command, Output};
 
-pub fn aux_build(args: &str) -> Output {
-    let (words, mut cmd) = build_common(args);
-    cmd.arg("--crate-type=lib");
-    for word in words {
-        cmd.arg(word);
-    }
-    let output = cmd.output().unwrap();
-    if !output.status.success() {
-        handle_failed_output(&format!("{:?}", cmd), output);
-    }
-    output
-}
-
-fn build_common(args: &str) -> (Vec<String>, Command) {
+fn setup_common_build_cmd() -> Command {
     let rustc = env::var("RUSTC").unwrap();
-    let words = shell_words::split(args).expect("failed to parse arguments");
     let mut cmd = Command::new(rustc);
     cmd.arg("--out-dir")
         .arg(env::var("TMPDIR").unwrap())
         .arg("-L")
         .arg(env::var("TMPDIR").unwrap());
-    (words, cmd)
+    cmd
 }
 
 fn handle_failed_output(cmd: &str, output: Output) -> ! {
@@ -33,19 +19,72 @@ fn handle_failed_output(cmd: &str, output: Output) -> ! {
     std::process::exit(1)
 }
 
-pub fn rustc(args: &str) -> Output {
-    let (words, mut cmd) = build_common(args);
-    for word in words {
-        cmd.arg(word);
+pub fn rustc() -> RustcInvocationBuilder {
+    RustcInvocationBuilder::new()
+}
+
+pub fn aux_build() -> AuxBuildInvocationBuilder {
+    AuxBuildInvocationBuilder::new()
+}
+
+#[derive(Debug)]
+pub struct RustcInvocationBuilder {
+    cmd: Command,
+}
+
+impl RustcInvocationBuilder {
+    fn new() -> Self {
+        let cmd = setup_common_build_cmd();
+        Self { cmd }
     }
-    let output = cmd.output().unwrap();
-    if !output.status.success() {
-        handle_failed_output(&format!("{:?}", cmd), output);
+
+    pub fn arg(&mut self, arg: &str) -> &mut RustcInvocationBuilder {
+        self.cmd.arg(arg);
+        self
+    }
+
+    pub fn run(&mut self) -> Output {
+        let output = self.cmd.output().unwrap();
+        if !output.status.success() {
+            handle_failed_output(&format!("{:?}", self.cmd), output);
+        }
+        output
+    }
+}
+
+#[derive(Debug)]
+pub struct AuxBuildInvocationBuilder {
+    cmd: Command,
+}
+
+impl AuxBuildInvocationBuilder {
+    fn new() -> Self {
+        let mut cmd = setup_common_build_cmd();
+        cmd.arg("--crate-type=lib");
+        Self { cmd }
+    }
+
+    pub fn arg(&mut self, arg: &str) -> &mut AuxBuildInvocationBuilder {
+        self.cmd.arg(arg);
+        self
+    }
+
+    pub fn run(&mut self) -> Output {
+        let output = self.cmd.output().unwrap();
+        if !output.status.success() {
+            handle_failed_output(&format!("{:?}", self.cmd), output);
+        }
+        output
     }
-    output
 }
 
 fn run_common(bin_name: &str) -> (Command, Output) {
+    let bin_name = if std::env::var("TARGET").unwrap().contains("windows") {
+        format!("{}.exe", bin_name)
+    } else {
+        bin_name.to_owned()
+    };
+
     let mut bin_path = PathBuf::new();
     bin_path.push(std::env::var("TMPDIR").unwrap());
     bin_path.push(&bin_name);

tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs

@@ -2,14 +2,23 @@
 
 extern crate run_make_support;
 
+use std::path::PathBuf;
+
 use run_make_support::{aux_build, rustc};
 
 fn main() {
-    aux_build("--emit=metadata stable.rs");
-    let output = rustc(&format!(
-        "--emit=metadata --extern stable={}/libstable.rmeta main.rs",
-        env!("TMPDIR")
-    ));
+    aux_build()
+        .arg("--emit=metadata")
+        .arg("stable.rs")
+        .run();
+    let mut stable_path = PathBuf::from(env!("TMPDIR"));
+    stable_path.push("libstable.rmeta");
+    let output = rustc()
+        .arg("--emit=metadata")
+        .arg("--extern")
+        .arg(&format!("stable={}", &stable_path.to_string_lossy()))
+        .arg("main.rs")
+        .run();
 
     let stderr = String::from_utf8_lossy(&output.stderr);
     let version = include_str!(concat!(env!("S"), "/src/version"));

tests/run-make/a-b-a-linker-guard/rmake.rs

@@ -5,9 +5,43 @@ extern crate run_make_support;
 use run_make_support::{run, run_fail, rustc};
 
 fn main() {
-    rustc("a.rs --cfg x -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy");
-    rustc("b.rs -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy");
+    rustc()
+        .arg("a.rs")
+        .arg("--cfg")
+        .arg("x")
+        .arg("-C")
+        .arg("prefer-dynamic")
+        .arg("-Z")
+        .arg("unstable-options")
+        .arg("-C")
+        .arg("symbol-mangling-version=legacy")
+        .run();
+
+     rustc()
+        .arg("b.rs")
+        .arg("--cfg")
+        .arg("x")
+        .arg("-C")
+        .arg("prefer-dynamic")
+        .arg("-Z")
+        .arg("unstable-options")
+        .arg("-C")
+        .arg("symbol-mangling-version=legacy")
+        .run();
+
     run("b");
-    rustc("a.rs --cfg y -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy");
+
+    rustc()
+        .arg("a.rs")
+        .arg("--cfg")
+        .arg("y")
+        .arg("-C")
+        .arg("prefer-dynamic")
+        .arg("-Z")
+        .arg("unstable-options")
+        .arg("-C")
+        .arg("symbol-mangling-version=legacy")
+        .run();
+
     run_fail("b");
 }