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

Author: jyn514

src/bootstrap/builder.rs

@@ -3,7 +3,7 @@ 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;
@@ -62,6 +62,17 @@ 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;
 
+    /// A user-visible name to display if this step fails.
+    fn name(&self) -> &'static str {
+        std::any::type_name::<Self>()
+    }
+
+    /// The path that should be used on the command line to run this step.
+    fn path(&self, builder: &Builder<'_>) -> PathBuf {
+        let paths = Self::should_run(ShouldRun::new(builder)).paths;
+        paths.iter().map(|pathset| pathset.path(builder)).next().expect("no paths for step")
+    }
+
     /// Primary function to execute this rule. Can call `builder.ensure()`
     /// with other steps to run those.
     fn run(self, builder: &Builder<'_>) -> Self::Output;
@@ -351,6 +362,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 {
@@ -610,6 +641,29 @@ impl<'a> Builder<'a> {
         StepDescription::run(v, self, paths);
     }
 
+    /// Print a command that will run the current step.
+    ///
+    /// This serves two purposes:
+    /// 1. Describe what step is currently being run.
+    /// 2. Describe how to run only this step in case it fails.
+    pub(crate) fn step_info(&self, step: &impl Step) {
+        if self.config.dry_run {
+            return;
+        }
+        print!(
+            "{} {} --stage {}",
+            // TODO: this is wrong, e.g. `check --stage 1` runs build commands first
+            self.kind,
+            step.path(self).display(),
+            // FIXME: top_stage might be higher than the stage of the step
+            self.top_stage,
+        );
+        for arg in self.config.cmd.test_args() {
+            print!(" --test-args \"{}\"", arg);
+        }
+        println!();
+    }
+
     /// Obtain a compiler at a given stage and for a given host. Explicitly does
     /// not take `Compiler` since all `Compiler` instances are meant to be
     /// obtained through this function, since it ensures that they are valid
@@ -1563,6 +1617,7 @@ impl<'a> Builder<'a> {
             let out = step.clone().run(self);
             let dur = start.elapsed();
             let deps = self.time_spent_on_dependencies.replace(parent + dur);
+
             (out, dur - deps)
         };
 

src/bootstrap/builder/tests.rs

@@ -511,7 +511,8 @@ mod dist {
                 target: host,
                 mode: Mode::Std,
                 test_kind: test::TestKind::Test,
-                krate: INTERNER.intern_str("std"),
+                krate_name: INTERNER.intern_str("std"),
+                krate_path: "library/std".into(),
             },]
         );
     }

src/bootstrap/cache.rs

@@ -271,15 +271,15 @@ impl Cache {
 
 #[cfg(test)]
 impl Cache {
-    pub fn all<S: Ord + Copy + Step>(&mut self) -> Vec<(S, S::Output)> {
+    pub fn all<S: Ord + Step>(&mut self) -> Vec<(S, S::Output)> {
         let cache = self.0.get_mut();
         let type_id = TypeId::of::<S>();
         let mut v = cache
             .remove(&type_id)
             .map(|b| b.downcast::<HashMap<S, S::Output>>().expect("correct type"))
             .map(|m| m.into_iter().collect::<Vec<_>>())
             .unwrap_or_default();
-        v.sort_by_key(|&(a, _)| a);
+        v.sort_by_key(|(a, _)| a.clone());
         v
     }
 

src/bootstrap/compile.rs

@@ -107,10 +107,11 @@ impl Step for Std {
         let mut cargo = builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "build");
         std_cargo(builder, target, compiler.stage, &mut cargo);
 
-        builder.info(&format!(
-            "Building stage{} std artifacts ({} -> {})",
-            compiler.stage, &compiler.host, target
-        ));
+        builder.step_info(&self);
+        // builder.info(&format!(
+        //     "Building stage{} std artifacts ({} -> {})",
+        //     compiler.stage, &compiler.host, target
+        // ));
         run_cargo(
             builder,
             cargo,

src/bootstrap/test.rs

@@ -1215,6 +1215,11 @@ impl Step for Compiletest {
         run.never()
     }
 
+    fn path(&self, _builder: &Builder<'_>) -> PathBuf {
+        // FIXME: it would be nice to suggest exactly the tests that fail, but that info isn't known without first running compiletest.
+        self.path.into()
+    }
+
     /// Executes the `compiletest` tool to run a suite of tests.
     ///
     /// Compiles all tests with `compiler` for `target` with the specified
@@ -1856,12 +1861,13 @@ impl Step for RustcGuide {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CrateLibrustc {
     compiler: Compiler,
     target: TargetSelection,
     test_kind: TestKind,
-    krate: Interned<String>,
+    krate_name: Interned<String>,
+    krate_path: PathBuf,
 }
 
 impl Step for CrateLibrustc {
@@ -1885,7 +1891,8 @@ impl Step for CrateLibrustc {
                     compiler,
                     target: run.target,
                     test_kind,
-                    krate: krate.name,
+                    krate_name: krate.name,
+                    krate_path: krate.local_path(builder.build),
                 });
             }
         }
@@ -1897,18 +1904,20 @@ impl Step for CrateLibrustc {
             target: self.target,
             mode: Mode::Rustc,
             test_kind: self.test_kind,
-            krate: self.krate,
+            krate_name: self.krate_name,
+            krate_path: self.krate_path.clone(),
         });
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Crate {
     pub compiler: Compiler,
     pub target: TargetSelection,
     pub mode: Mode,
     pub test_kind: TestKind,
-    pub krate: Interned<String>,
+    pub krate_name: Interned<String>,
+    pub krate_path: PathBuf,
 }
 
 impl Step for Crate {
@@ -1931,7 +1940,8 @@ impl Step for Crate {
                 target: run.target,
                 mode,
                 test_kind,
-                krate: krate.name,
+                krate_name: krate.name,
+                krate_path: krate.local_path(builder.build),
             });
         };
 
@@ -1942,6 +1952,10 @@ impl Step for Crate {
         }
     }
 
+    fn path(&self, _builder: &Builder<'_>) -> PathBuf {
+        self.krate_path.file_name().expect("top-level directory is not a crate").into()
+    }
+
     /// Runs all unit tests plus documentation tests for a given crate defined
     /// by a `Cargo.toml` (single manifest)
     ///
@@ -1955,7 +1969,7 @@ impl Step for Crate {
         let target = self.target;
         let mode = self.mode;
         let test_kind = self.test_kind;
-        let krate = self.krate;
+        let krate = self.krate_name;
 
         builder.ensure(compile::Std { compiler, target });
         builder.ensure(RemoteCopyLibs { compiler, target });