Add behavior on failure to BootstrapCommand

Author: Kobzol

src/bootstrap/exec.rs

@@ -1,21 +1,32 @@
 use std::process::Command;
 
+/// What should be done when the command fails.
+#[derive(Debug, Copy, Clone)]
+pub enum BehaviorOnFailure {
+    /// Immediately stop bootstrap.
+    Exit,
+    /// Delay failure until the end of bootstrap invocation.
+    DelayFail,
+}
+
 /// Wrapper around `std::process::Command`.
 #[derive(Debug)]
 pub struct BootstrapCommand<'a> {
     pub command: &'a mut Command,
-    /// Report failure later instead of immediately.
-    pub delay_failure: bool,
+    pub failure_behavior: Option<BehaviorOnFailure>,
 }
 
 impl<'a> BootstrapCommand<'a> {
     pub fn delay_failure(self) -> Self {
-        Self { delay_failure: true, ..self }
+        Self { failure_behavior: Some(BehaviorOnFailure::DelayFail), ..self }
+    }
+    pub fn fail_fast(self) -> Self {
+        Self { failure_behavior: Some(BehaviorOnFailure::Exit), ..self }
     }
 }
 
 impl<'a> From<&'a mut Command> for BootstrapCommand<'a> {
     fn from(command: &'a mut Command) -> Self {
-        Self { command, delay_failure: false }
+        Self { command, failure_behavior: None }
     }
 }

src/bootstrap/lib.rs

@@ -28,16 +28,21 @@ use std::str;
 
 use build_helper::ci::{gha, CiEnv};
 use build_helper::exit;
-use channel::GitInfo;
-use config::{DryRun, Target};
 use filetime::FileTime;
 use once_cell::sync::OnceCell;
+use termcolor::{ColorChoice, StandardStream, WriteColor};
+
+use channel::GitInfo;
+use config::{DryRun, Target};
 
 use crate::builder::Kind;
+pub use crate::builder::PathSet;
+use crate::cache::{Interned, INTERNER};
+pub use crate::config::Config;
 use crate::config::{LlvmLibunwind, TargetSelection};
-use crate::util::{
-    dir_is_empty, exe, libdir, mtime, output, run, run_suppressed, symlink_dir, try_run_suppressed,
-};
+use crate::exec::{BehaviorOnFailure, BootstrapCommand};
+pub use crate::flags::Subcommand;
+use crate::util::{dir_is_empty, exe, libdir, mtime, output, run, symlink_dir};
 
 mod builder;
 mod cache;
@@ -88,13 +93,6 @@ mod job {
     pub unsafe fn setup(_build: &mut crate::Build) {}
 }
 
-pub use crate::builder::PathSet;
-use crate::cache::{Interned, INTERNER};
-pub use crate::config::Config;
-use crate::exec::BootstrapCommand;
-pub use crate::flags::Subcommand;
-use termcolor::{ColorChoice, StandardStream, WriteColor};
-
 const LLVM_TOOLS: &[&str] = &[
     "llvm-cov",      // used to generate coverage report
     "llvm-nm",       // used to inspect binaries; it shows symbol names, their sizes and visibility
@@ -967,44 +965,30 @@ impl Build {
 
     /// Runs a command, printing out nice contextual information if it fails.
     fn run(&self, cmd: &mut Command) {
-        if self.config.dry_run() {
-            return;
-        }
-        self.verbose(&format!("running: {cmd:?}"));
-        run(cmd, self.is_verbose())
+        // FIXME: output mode -> status + err if self.is_verbose()
+        let cmd: BootstrapCommand<'_> = cmd.into();
+        self.run_cmd(cmd.fail_fast());
     }
 
     /// Runs a command, printing out nice contextual information if it fails.
     fn run_quiet(&self, cmd: &mut Command) {
-        if self.config.dry_run() {
-            return;
-        }
-        self.verbose(&format!("running: {cmd:?}"));
-        run_suppressed(cmd)
+        // FIXME: output mode -> output + err
+        let cmd: BootstrapCommand<'_> = cmd.into();
+        self.run_cmd(cmd.fail_fast());
     }
 
     /// Runs a command, printing out nice contextual information if it fails.
     /// Exits if the command failed to execute at all, otherwise returns its
     /// `status.success()`.
     fn run_quiet_delaying_failure(&self, cmd: &mut Command) -> bool {
-        if self.config.dry_run() {
-            return true;
-        }
-        if !self.fail_fast {
-            self.verbose(&format!("running: {cmd:?}"));
-            if !try_run_suppressed(cmd) {
-                let mut failures = self.delayed_failures.borrow_mut();
-                failures.push(format!("{cmd:?}"));
-                return false;
-            }
-        } else {
-            self.run_quiet(cmd);
-        }
-        true
+        // FIXME: output mode -> output + err
+        let cmd: BootstrapCommand<'_> = cmd.into();
+        self.run_cmd(cmd.delay_failure())
     }
 
     /// Runs a command, printing out contextual info if it fails, and delaying errors until the build finishes.
     pub(crate) fn run_delaying_failure(&self, cmd: &mut Command) -> bool {
+        // FIXME: output mode -> status + err if self.is_verbose()
         let cmd: BootstrapCommand<'_> = cmd.into();
         self.run_cmd(cmd.delay_failure())
     }
@@ -1020,10 +1004,16 @@ impl Build {
         match result {
             Ok(_) => true,
             Err(_) => {
-                if command.delay_failure {
-                    let mut failures = self.delayed_failures.borrow_mut();
-                    failures.push(format!("{command:?}"));
-                    return false;
+                if let Some(failure_behavior) = command.failure_behavior {
+                    match failure_behavior {
+                        BehaviorOnFailure::DelayFail => {
+                            let mut failures = self.delayed_failures.borrow_mut();
+                            failures.push(format!("{command:?}"));
+                        }
+                        BehaviorOnFailure::Exit => {
+                            exit!(1);
+                        }
+                    }
                 }
                 if self.fail_fast {
                     exit!(1);