Use compiler() instead of stage()

Author: jyn514

src/bootstrap/builder.rs

@@ -67,16 +67,26 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
         std::any::type_name::<Self>()
     }
 
+    // fn kind(&self) -> Kind;
+
+    fn compiler(&self) -> Option<&Compiler> {
+        None
+    }
+
+    fn target(&self) -> Option<&TargetSelection> {
+        None
+    }
+
     /// 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")
     }
 
-    /// The stage that should be passed to x.py to run this step.
-    fn stage(&self, builder: &Builder<'_>) -> u32 {
-        builder.top_stage
-    }
+    // /// The stage that should be passed to x.py to run this step.
+    // fn stage(&self, builder: &Builder<'_>) -> u32 {
+    //     builder.top_stage
+    // }
 
     /// Primary function to execute this rule. Can call `builder.ensure()`
     /// with other steps to run those.
@@ -655,13 +665,24 @@ impl<'a> Builder<'a> {
         if self.config.dry_run {
             return;
         }
+        let (stage, host) = if let Some(compiler) = step.compiler() {
+            (compiler.stage, Some(compiler.host))
+        } else {
+            (self.top_stage, None)
+        };
         print!(
             "{} {} --stage {}",
             // TODO: this is wrong, e.g. `check --stage 1` runs build commands first
             self.kind,
             step.path(self).display(),
-            step.stage(self),
+            stage,
         );
+        if let Some(host) = host {
+            print!(" --host {}", host);
+        }
+        if let Some(target) = step.target() {
+            print!(" --target {}", target);
+        }
         for arg in self.config.cmd.test_args() {
             print!(" --test-args \"{}\"", arg);
         }

src/bootstrap/compile.rs

@@ -54,6 +54,14 @@ impl Step for Std {
         });
     }
 
+    fn compiler(&self) -> Option<&Compiler> {
+        Some(&self.compiler)
+    }
+
+    fn target(&self) -> Option<&TargetSelection> {
+        Some(&self.target)
+    }
+
     /// Builds the standard library.
     ///
     /// This will build the standard library for a particular stage of the build
@@ -519,10 +527,14 @@ impl Step for Rustc {
         });
     }
 
-    fn stage(&self, _builder: &Builder<'_>) -> u32 {
-        self.compiler.stage
+    fn compiler(&self) -> Option<&Compiler> {
+        Some(&self.compiler)
     }
 
+    // fn stage(&self, _builder: &Builder<'_>) -> u32 {
+    //     self.compiler.stage
+    // }
+
     /// Builds the compiler.
     ///
     /// This will build the compiler for a particular stage of the build using

src/bootstrap/tool.rs

@@ -319,8 +319,16 @@ macro_rules! bootstrap_tool {
         impl Step for $name {
             type Output = PathBuf;
 
-            fn stage(&self, _builder: &Builder<'_>) -> u32 {
-                self.compiler.stage
+            // fn stage(&self, _builder: &Builder<'_>) -> u32 {
+            //     self.compiler.stage
+            // }
+
+            fn compiler(&self) -> Option<&Compiler> {
+                Some(&self.compiler)
+            }
+
+            fn target(&self) -> Option<&TargetSelection> {
+                Some(&self.target)
             }
 
             fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
@@ -599,8 +607,16 @@ impl Step for Cargo {
     const DEFAULT: bool = true;
     const ONLY_HOSTS: bool = true;
 
-    fn stage(&self, _builder: &Builder<'_>) -> u32 {
-        self.compiler.stage
+    // fn stage(&self, _builder: &Builder<'_>) -> u32 {
+    //     self.compiler.stage
+    // }
+
+    fn compiler(&self) -> Option<&Compiler> {
+        Some(&self.compiler)
+    }
+
+    fn target(&self) -> Option<&TargetSelection> {
+        Some(&self.target)
     }
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {

src/bootstrap/toolstate.rs

@@ -1,4 +1,4 @@
-use crate::builder::{Builder, RunConfig, ShouldRun, Step};
+use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
 use build_helper::t;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -141,6 +141,10 @@ pub struct ToolStateCheck;
 impl Step for ToolStateCheck {
     type Output = ();
 
+    // fn kind(&self) -> Kind {
+    //     Kind::Test
+    // }
+
     /// Checks tool state status.
     ///
     /// This is intended to be used in the `checktools.sh` script. To use