Fix command suggestion for tests

- Allow overriding the path shown per-step
- Override the path for the `Crate` step
- Add `--stage` to the suggestion

Author: jyn514

src/bootstrap/builder.rs

@@ -63,10 +63,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;
@@ -1560,13 +1567,13 @@ 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 {
                 color: self.build.config.color,
-                name: step.name(),
                 cmd: self.kind,
-                path: path.expect("no paths for step"),
+                name: step.name(),
+                path: step.path(self),
+                // FIXME: top_stage might be higher than the stage of the step
+                stage: self.top_stage,
             };
             // NOTE: don't hold onto this guard, it will cause a deadlock if the current step calls `ensure` recursively.
             let old_instructions = CURRENT_INSTRUCTIONS
@@ -1606,6 +1613,7 @@ struct ReplicationStep {
     cmd: Kind,
     name: &'static str,
     path: PathBuf,
+    stage: u32,
 }
 
 lazy_static! {
@@ -1632,9 +1640,10 @@ pub(crate) extern "C" fn print_replication_steps() {
         let _ = stdout.reset();
         let _ = writeln!(
             stdout,
-            ": to replicate this failure, run `./x.py {} {}`",
+            ": to replicate this failure, run `./x.py {} {} --stage {}`",
             step.cmd,
-            step.path.display()
+            step.path.display(),
+            step.stage,
         );
     }
 }

src/bootstrap/test.rs

@@ -1788,12 +1788,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 {
@@ -1817,7 +1818,8 @@ impl Step for CrateLibrustc {
                     compiler,
                     target: run.target,
                     test_kind,
-                    krate: krate.name,
+                    krate_name: krate.name,
+                    krate_path: krate.path.clone(),
                 });
             }
         }
@@ -1829,18 +1831,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 {
@@ -1863,7 +1867,8 @@ impl Step for Crate {
                 target: run.target,
                 mode,
                 test_kind,
-                krate: krate.name,
+                krate_name: krate.name,
+                krate_path: krate.path.clone(),
             });
         };
 
@@ -1874,6 +1879,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)
     ///
@@ -1887,7 +1896,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 });