Print active bootstrap step stack when a failure happens on CI

Author: Kobzol

src/bootstrap/src/core/builder/mod.rs

@@ -1,11 +1,11 @@
 use std::any::{Any, type_name};
-use std::cell::{Cell, RefCell};
+use std::cell::Cell;
 use std::collections::BTreeSet;
 use std::fmt::{self, Debug, Write};
 use std::hash::Hash;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
-use std::sync::{LazyLock, OnceLock};
+use std::sync::{Arc, LazyLock, Mutex, OnceLock};
 use std::time::{Duration, Instant};
 use std::{env, fs};
 
@@ -32,6 +32,25 @@ mod cargo;
 #[cfg(test)]
 mod tests;
 
+type StepStack = Arc<Mutex<Vec<Box<dyn AnyDebug>>>>;
+
+/// Pointer to the active step stack of the currently executing `Builder`.
+static ACTIVE_BUILDER_STEP_STACK: Mutex<Option<StepStack>> = Mutex::new(None);
+
+/// Prints the current contents of the active builder's step stack.
+fn print_step_stack() {
+    if let Ok(stack) = ACTIVE_BUILDER_STEP_STACK.try_lock()
+        && let Some(ref stack) = *stack
+        && let Ok(stack) = stack.try_lock()
+    {
+        eprintln!("\n---BOOTSTRAP step stack start---\n");
+        for step in &*stack {
+            eprintln!("{step:?}");
+        }
+        eprintln!("\n---BOOTSTRAP step stack end---\n");
+    }
+}
+
 /// Builds and performs different [`Self::kind`]s of stuff and actions, taking
 /// into account build configuration from e.g. bootstrap.toml.
 pub struct Builder<'a> {
@@ -52,7 +71,7 @@ pub struct Builder<'a> {
 
     /// A stack of [`Step`]s to run before we can run this builder. The output
     /// of steps is cached in [`Self::cache`].
-    stack: RefCell<Vec<Box<dyn AnyDebug>>>,
+    stack: StepStack,
 
     /// The total amount of time we spent running [`Step`]s in [`Self::stack`].
     time_spent_on_dependencies: Cell<Duration>,
@@ -78,8 +97,8 @@ impl Deref for Builder<'_> {
 /// type's [`Debug`] implementation.
 ///
 /// (Trying to debug-print `dyn Any` results in the unhelpful `"Any { .. }"`.)
-pub trait AnyDebug: Any + Debug {}
-impl<T: Any + Debug> AnyDebug for T {}
+pub trait AnyDebug: Any + Debug + Send {}
+impl<T: Any + Debug + Send> AnyDebug for T {}
 impl dyn AnyDebug {
     /// Equivalent to `<dyn Any>::downcast_ref`.
     fn downcast_ref<T: Any>(&self) -> Option<&T> {
@@ -89,7 +108,7 @@ impl dyn AnyDebug {
     // Feel free to add other `dyn Any` methods as necessary.
 }
 
-pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
+pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash + Send {
     /// Result type of `Step::run`.
     type Output: Clone;
 
@@ -1265,12 +1284,20 @@ impl<'a> Builder<'a> {
     }
 
     fn new_internal(build: &Build, kind: Kind, paths: Vec<PathBuf>) -> Builder<'_> {
+        let stack = Arc::new(Mutex::new(Vec::new()));
+
+        // Store the current step stack
+        *ACTIVE_BUILDER_STEP_STACK.lock().unwrap() = Some(stack.clone());
+
+        // And configure `build_helper` to print it on exit
+        *build_helper::util::EXIT_CONTEXT.lock().unwrap() = Some(print_step_stack);
+
         Builder {
             build,
             top_stage: build.config.stage,
             kind,
             cache: Cache::new(),
-            stack: RefCell::new(Vec::new()),
+            stack,
             time_spent_on_dependencies: Cell::new(Duration::new(0, 0)),
             paths,
             submodule_paths_cache: Default::default(),
@@ -1673,9 +1700,9 @@ You have to build a stage1 compiler for `{}` first, and then use it to build a s
     /// Ensure that a given step is built, returning its output. This will
     /// cache the step, so it is safe (and good!) to call this as often as
     /// needed to ensure that all dependencies are built.
-    pub fn ensure<S: Step>(&'a self, step: S) -> S::Output {
+    pub fn ensure<S: Step + Send>(&'a self, step: S) -> S::Output {
         {
-            let mut stack = self.stack.borrow_mut();
+            let mut stack = self.stack.lock().unwrap();
             for stack_step in stack.iter() {
                 // should skip
                 if stack_step.downcast_ref::<S>().is_none_or(|stack_step| *stack_step != step) {
@@ -1754,7 +1781,7 @@ You have to build a stage1 compiler for `{}` first, and then use it to build a s
         self.metrics.exit_step(self);
 
         {
-            let mut stack = self.stack.borrow_mut();
+            let mut stack = self.stack.lock().unwrap();
             let cur_step = stack.pop().expect("step stack empty");
             assert_eq!(cur_step.downcast_ref(), Some(&step));
         }

src/build_helper/src/util.rs

@@ -2,6 +2,7 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::Path;
 use std::process::Command;
+use std::sync::Mutex;
 
 use crate::ci::CiEnv;
 
@@ -15,6 +16,10 @@ macro_rules! exit {
     };
 }
 
+/// When the program ends using `detail_exit`, this function will be called (if present)
+/// to output additional context.
+pub static EXIT_CONTEXT: Mutex<Option<fn()>> = Mutex::new(None);
+
 /// If code is not 0 (successful exit status), exit status is 101 (rust's default error code.)
 /// If `is_test` true and code is an error code, it will cause a panic.
 pub fn detail_exit(code: i32, is_test: bool) -> ! {
@@ -28,7 +33,13 @@ pub fn detail_exit(code: i32, is_test: bool) -> ! {
             // Skip the first argument, as it will be some absolute path to the bootstrap binary.
             let bootstrap_args =
                 std::env::args().skip(1).map(|a| a.to_string()).collect::<Vec<_>>().join(" ");
-            eprintln!("Bootstrap failed while executing `{bootstrap_args}`");
+            eprintln!("Bootstrap failed while executing `x {bootstrap_args}`");
+
+            if let Ok(ctx) = EXIT_CONTEXT.lock() {
+                if let Some(ctx) = *ctx {
+                    ctx();
+                }
+            }
         }
 
         // otherwise, exit with provided status code