move exit-code to rmake

Author: 5225225

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

@@ -1,16 +1,28 @@
 use std::env;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
-
+mod rustdoc;
+pub use rustdoc::rustdoc;
 pub use wasmparser;
 
+pub fn add_host_rpath_env(cmd: &mut Command) {
+    let ld_lib_path_envvar = env::var("LD_LIB_PATH_ENVVAR").unwrap();
+    let ld_lib_path_value = env::var(&ld_lib_path_envvar).unwrap();
+
+    let temp = env::var("TMPDIR").unwrap();
+    let host_rpath_dir = env::var("HOST_RPATH_DIR").unwrap();
+
+    cmd.env(ld_lib_path_envvar, format!("{temp}:{host_rpath_dir}:{ld_lib_path_value}"));
+}
+
 pub fn out_dir() -> PathBuf {
     env::var_os("TMPDIR").unwrap().into()
 }
 
-fn setup_common_build_cmd() -> Command {
+fn setup_common_rustc_build_cmd() -> Command {
     let rustc = env::var("RUSTC").unwrap();
     let mut cmd = Command::new(rustc);
+    add_host_rpath_env(&mut cmd);
     cmd.arg("--out-dir").arg(out_dir()).arg("-L").arg(out_dir());
     cmd
 }
@@ -39,7 +51,7 @@ pub struct RustcInvocationBuilder {
 
 impl RustcInvocationBuilder {
     fn new() -> Self {
-        let cmd = setup_common_build_cmd();
+        let cmd = setup_common_rustc_build_cmd();
         Self { cmd }
     }
 
@@ -53,6 +65,11 @@ impl RustcInvocationBuilder {
         self
     }
 
+    pub fn env(&mut self, key: &str, value: &str) -> &mut RustcInvocationBuilder {
+        self.cmd.env(key, value);
+        self
+    }
+
     #[track_caller]
     pub fn run(&mut self) -> Output {
         let caller_location = std::panic::Location::caller();
@@ -64,6 +81,30 @@ impl RustcInvocationBuilder {
         }
         output
     }
+
+    #[track_caller]
+    pub fn run_fail(&mut self) -> Output {
+        let caller_location = std::panic::Location::caller();
+        let caller_line_number = caller_location.line();
+
+        let output = self.cmd.output().unwrap();
+        if output.status.success() {
+            handle_failed_output(&format!("{:#?}", self.cmd), output, caller_line_number);
+        }
+        output
+    }
+
+    #[track_caller]
+    pub fn run_fail_assert_exit_code(&mut self, code: i32) -> Output {
+        let caller_location = std::panic::Location::caller();
+        let caller_line_number = caller_location.line();
+
+        let output = self.cmd.output().unwrap();
+        if output.status.code().unwrap() != code {
+            handle_failed_output(&format!("{:#?}", self.cmd), output, caller_line_number);
+        }
+        output
+    }
 }
 
 #[derive(Debug)]
@@ -73,7 +114,7 @@ pub struct AuxBuildInvocationBuilder {
 
 impl AuxBuildInvocationBuilder {
     fn new() -> Self {
-        let mut cmd = setup_common_build_cmd();
+        let mut cmd = setup_common_rustc_build_cmd();
         cmd.arg("--crate-type=lib");
         Self { cmd }
     }

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

@@ -0,0 +1,105 @@
+use std::env;
+use std::path::Path;
+use std::process::{Command, Output};
+
+use crate::{add_host_rpath_env, handle_failed_output};
+
+pub fn rustdoc() -> RustdocInvocationBuilder {
+    RustdocInvocationBuilder::new()
+}
+
+#[derive(Debug)]
+pub struct RustdocInvocationBuilder {
+    cmd: Command,
+}
+
+impl RustdocInvocationBuilder {
+    fn new() -> Self {
+        let cmd = setup_common_rustdoc_build_cmd();
+        Self { cmd }
+    }
+
+    pub fn arg(&mut self, arg: &str) -> &mut RustdocInvocationBuilder {
+        self.cmd.arg(arg);
+        self
+    }
+
+    pub fn arg_file(&mut self, arg: &Path) -> &mut RustdocInvocationBuilder {
+        self.cmd.arg(arg);
+        self
+    }
+
+    pub fn env(&mut self, key: &str, value: &str) -> &mut RustdocInvocationBuilder {
+        self.cmd.env(key, value);
+        self
+    }
+
+    #[track_caller]
+    pub fn run(&mut self) -> Output {
+        let caller_location = std::panic::Location::caller();
+        let caller_line_number = caller_location.line();
+
+        let output = self.cmd.output().unwrap();
+        if !output.status.success() {
+            handle_failed_output(&format!("{:#?}", self.cmd), output, caller_line_number);
+        }
+        output
+    }
+
+    #[track_caller]
+    pub fn run_fail(&mut self) -> Output {
+        let caller_location = std::panic::Location::caller();
+        let caller_line_number = caller_location.line();
+
+        let output = self.cmd.output().unwrap();
+        if output.status.success() {
+            handle_failed_output(&format!("{:#?}", self.cmd), output, caller_line_number);
+        }
+        output
+    }
+
+    #[track_caller]
+    pub fn run_fail_assert_exit_code(&mut self, code: i32) -> Output {
+        let caller_location = std::panic::Location::caller();
+        let caller_line_number = caller_location.line();
+
+        let output = self.cmd.output().unwrap();
+        if output.status.code().unwrap() != code {
+            handle_failed_output(&format!("{:#?}", self.cmd), output, caller_line_number);
+        }
+        output
+    }
+}
+
+fn setup_common_rustdoc_build_cmd() -> Command {
+    use std::env::VarError;
+
+    let rustdoc = env::var("RUSTDOC").unwrap();
+    let target_rpath_dir = env::var("TARGET_RPATH_DIR").unwrap();
+
+    //let ld_lib_path_envvar = env::var("LD_LIB_PATH_ENVVAR").unwrap();
+    // let ld_lib_path_value = env::var(&ld_lib_path_envvar).unwrap();
+
+    //let temp = env::var("TMPDIR").unwrap();
+    //let host_rpath_dir = env::var("HOST_RPATH_DIR").unwrap();
+
+    let mut cmd = Command::new(rustdoc);
+
+    // cmd.env(ld_lib_path_envvar, format!("{temp}:{host_rpath_dir}:{ld_lib_path_value}"));
+
+    add_host_rpath_env(&mut cmd);
+
+    cmd.arg("-L").arg(target_rpath_dir);
+
+    match std::env::var("RUSTC_LINKER") {
+        Ok(rustc_linker) => {
+            cmd.arg(&format!("-Clinker='{rustc_linker}'"));
+        }
+        Err(VarError::NotPresent) => {}
+        Err(VarError::NotUnicode(s)) => {
+            panic!("RUSTC_LINKER was found, but set to non-unicode string {s:?}");
+        }
+    }
+
+    cmd
+}

tests/run-make/exit-code/Makefile

@@ -0,0 +1,41 @@
+extern crate run_make_support;
+
+use run_make_support::{rustc, rustdoc, out_dir};
+
+fn main() {
+    rustc()
+        .arg("success.rs")
+        .run();
+
+    rustc()
+        .arg("--invalid-arg-foo")
+        .run_fail_assert_exit_code(1);
+
+    rustc()
+        .arg("compile-error.rs")
+        .run_fail_assert_exit_code(1);
+
+    rustc()
+        .env("RUSTC_ICE", "0")
+        .arg("-Ztreat-err-as-bug")
+        .arg("compile-error.rs")
+        .run_fail_assert_exit_code(101);
+
+    rustdoc()
+        .arg("-o")
+        .arg_file(&out_dir().join("exit-code"))
+        .arg("success.rs")
+        .run();
+
+    rustdoc()
+        .arg("--invalid-arg-foo")
+        .run_fail_assert_exit_code(1);
+
+    rustdoc()
+        .arg("compile-error.rs")
+        .run_fail_assert_exit_code(1);
+
+    rustdoc()
+        .arg("lint-failure.rs")
+        .run_fail_assert_exit_code(1);
+}