Give dynamically generated instructions on how to replicate errors during the build progress

Example output:

```
Checking stage0 rustdoc artifacts (x86_64-unknown-linux-gnu -> x86_64-unknown-linux-gnu)
    Checking rustdoc v0.0.0 (/home/joshua/rustc/src/librustdoc)
error: expected item, found `/`
 --> src/librustdoc/lib.rs:1:1
  |
1 | /
  | ^ expected item

error: aborting due to previous error

error: could not compile `rustdoc`

To learn more, run the command again with --verbose.
command did not execute successfully: "/home/joshua/rustc/build/x86_64-unknown-linux-gnu/stage0/bin/cargo" "check" "--target" "x86_64-unknown-linux-gnu" "-Zbinary-dep-depinfo" "-j" "8" "--release" "--manifest-path" "/home/joshua/rustc/src/tools/rustdoc/Cargo.toml" "--message-format" "json-render-diagnostics"
expected success, got: exit status: 101
note: failed while building bootstrap::check::Rustdoc
help: to replicate this failure, run `./x.py check src/librustdoc`
failed to run: /home/joshua/rustc/build/bootstrap/debug/bootstrap check src/librustdoc
Build completed unsuccessfully in 0:00:01
```

Happy to take suggestions on how to improve the error message :) right
now it's getting lost in all the other output. Maybe it makes sense to
use bold and colors?

This works by storing the current step at all times in a global Mutex
and registering an `at_exit` handler which looks up the current step.

Author: jyn514

src/bootstrap/builder.rs

@@ -3,15 +3,17 @@ use std::cell::{Cell, RefCell};
 use std::collections::BTreeSet;
 use std::env;
 use std::ffi::OsStr;
-use std::fmt::Debug;
+use std::fmt::{self, Debug, Display};
 use std::fs;
 use std::hash::Hash;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
 use build_helper::{output, t};
+use lazy_static::lazy_static;
 
 use crate::cache::{Cache, Interned, INTERNER};
 use crate::check;
@@ -60,6 +62,10 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
     /// If true, then this rule should be skipped if --target was specified, but --host was not
     const ONLY_HOSTS: bool = false;
 
+    fn name(&self) -> &'static str {
+        std::any::type_name::<Self>()
+    }
+
     /// Primary function to execute this rule. Can call `builder.ensure()`
     /// with other steps to run those.
     fn run(self, builder: &Builder<'_>) -> Self::Output;
@@ -333,6 +339,26 @@ pub enum Kind {
     Run,
 }
 
+impl Display for Kind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use Kind::*;
+        let s = match self {
+            Build => "build",
+            Check => "check",
+            Clippy => "clippy",
+            Fix => "fix",
+            Format => "fmt",
+            Test => "test",
+            Bench => "bench",
+            Dist => "dist",
+            Doc => "doc",
+            Install => "install",
+            Run => "run",
+        };
+        f.write_str(s)
+    }
+}
+
 impl<'a> Builder<'a> {
     fn get_step_descriptions(kind: Kind) -> Vec<StepDescription> {
         macro_rules! describe {
@@ -1533,12 +1559,28 @@ impl<'a> Builder<'a> {
         }
 
         let (out, dur) = {
+            let paths = S::should_run(ShouldRun::new(self)).paths;
+            let path = paths.iter().map(|pathset| pathset.path(self)).next();
+            let instructions = ReplicationStep {
+                name: step.name(),
+                cmd: self.kind,
+                path: path.expect("no paths for step"),
+            };
+            // NOTE: don't hold onto this guard, it will cause a deadlock if the current step calls `ensure` recursively.
+            let old_instructions = CURRENT_INSTRUCTIONS
+                .lock()
+                .expect("steps are not run in parallel")
+                .replace(instructions);
+
             let start = Instant::now();
             let zero = Duration::new(0, 0);
             let parent = self.time_spent_on_dependencies.replace(zero);
             let out = step.clone().run(self);
             let dur = start.elapsed();
             let deps = self.time_spent_on_dependencies.replace(parent + dur);
+
+            *CURRENT_INSTRUCTIONS.lock().expect("steps are not run in parallel") = old_instructions;
+
             (out, dur - deps)
         };
 
@@ -1557,6 +1599,28 @@ impl<'a> Builder<'a> {
     }
 }
 
+struct ReplicationStep {
+    cmd: Kind,
+    name: &'static str,
+    path: PathBuf,
+}
+
+lazy_static! {
+    static ref CURRENT_INSTRUCTIONS: Mutex<Option<ReplicationStep>> = Mutex::new(None);
+}
+
+pub(crate) extern "C" fn print_replication_steps() {
+    if let Some(step) = CURRENT_INSTRUCTIONS.lock().expect("mutex guard is dropped on panic").take()
+    {
+        println!("note: failed while building {}", step.name);
+        println!(
+            "help: to replicate this failure, run `./x.py {} {}`",
+            step.cmd,
+            step.path.display()
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests;
 

src/bootstrap/job.rs

@@ -47,6 +47,8 @@ use winapi::um::winnt::{
 };
 
 pub unsafe fn setup(build: &mut Build) {
+    libc::atexit(print_replication_steps);
+
     // Enable the Windows Error Reporting dialog which msys disables,
     // so we can JIT debug rustc
     let mode = SetErrorMode(0);

src/bootstrap/lib.rs

@@ -154,6 +154,7 @@ mod job;
 #[cfg(all(unix, not(target_os = "haiku")))]
 mod job {
     pub unsafe fn setup(build: &mut crate::Build) {
+        libc::atexit(crate::builder::print_replication_steps);
         if build.config.low_priority {
             libc::setpriority(libc::PRIO_PGRP as _, 0, 10);
         }