rewrite some more code

Author: jyn514

src/bootstrap/builder.rs

@@ -1,4 +1,5 @@
 use std::any::Any;
+use std::borrow::Cow;
 use std::cell::{Cell, RefCell};
 use std::collections::BTreeSet;
 use std::env;
@@ -50,7 +51,7 @@ impl<'a> Deref for Builder<'a> {
     }
 }
 
-pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
+pub(crate) trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
     /// `PathBuf` when directories are created or to return a `Compiler` once
     /// it's been assembled.
     type Output: Clone;
@@ -67,15 +68,7 @@ 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
-    }
+    fn info(_step_info: &mut StepInfo<'_, '_, Self>) {}
 
     /// The path that should be used on the command line to run this step.
     fn path(&self, builder: &Builder<'_>) -> PathBuf {
@@ -656,37 +649,10 @@ 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;
-        }
-        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(),
-            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);
-        }
-        println!();
+        let mut info = StepInfo::new(self, step);
+        Step::info(&mut info);
+        info.print();
     }
 
     /// Obtain a compiler at a given stage and for a given host. Explicitly does
@@ -1611,7 +1577,7 @@ impl<'a> Builder<'a> {
     /// 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(crate) fn ensure<S: Step>(&'a self, step: S) -> S::Output {
         {
             let mut stack = self.stack.borrow_mut();
             for stack_step in stack.iter() {
@@ -1772,3 +1738,105 @@ impl From<Cargo> for Command {
         cargo.command
     }
 }
+
+pub(crate) struct StepInfo<'a, 'b, S> {
+    pub(crate) builder: &'a Builder<'b>,
+    pub(crate) step: &'a S,
+    compiler: Option<Cow<'a, Compiler>>,
+    stage: Option<u32>,
+    host: Option<TargetSelection>,
+    target: Option<TargetSelection>,
+    cmd: Option<Kind>,
+}
+
+impl<'a> From<Compiler> for Cow<'a, Compiler> {
+    fn from(val: Compiler) -> Self {
+        Self::Owned(val)
+    }
+}
+
+impl<'a> From<&'a Compiler> for Cow<'a, Compiler> {
+    fn from(val: &'a Compiler) -> Self {
+        Self::Borrowed(val)
+    }
+}
+
+impl<'a, 'b, S> StepInfo<'a, 'b, S> {
+    pub(crate) fn new(builder: &'a Builder<'b>, step: &'a S) -> Self {
+        Self { builder, step, compiler: None, stage: None, host: None, target: None, cmd: None }
+    }
+
+    pub(crate) fn compiler(&mut self, val: impl Into<Cow<'a, Compiler>>) -> &mut Self {
+        if self.compiler.is_some() {
+            panic!("cannot overwrite compiler");
+        }
+        let val = val.into();
+        self.stage(val.stage).host(val.host);
+        self.compiler = Some(val);
+        self
+    }
+
+    pub(crate) fn stage(&mut self, stage: u32) -> &mut Self {
+        if self.stage.is_some() {
+            panic!("cannot overwrite stage");
+        }
+        self.stage = Some(stage);
+        self
+    }
+
+    pub(crate) fn host(&mut self, host: TargetSelection) -> &mut Self {
+        if self.host.is_some() {
+            panic!("cannot overwrite host");
+        }
+        self.host = Some(host);
+        self
+    }
+
+    pub(crate) fn target(&mut self, target: TargetSelection) -> &mut Self {
+        if self.target.is_some() {
+            panic!("cannot overwrite target");
+        }
+        self.target = Some(target);
+        self
+    }
+
+    pub(crate) fn cmd(&mut self, val: Kind) -> &mut Self {
+        if self.cmd.is_some() {
+            panic!("cannot overwrite cmd");
+        }
+        self.cmd = Some(val);
+        self
+    }
+
+    /// 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 print(&self)
+    where
+        S: Step,
+    {
+        if self.builder.config.dry_run {
+            return;
+        }
+        // let stage = self.stage.unwrap_or(self.builder.top_stage);
+        let stage = self.stage.expect("missing stage");
+        let host = self.host;
+        let kind = self.cmd.unwrap_or(self.builder.kind);
+        let target = self.target;
+        print!("{} {} --stage {}", kind, self.step.path(self.builder).display(), stage,);
+        if let Some(host) = host {
+            print!(" --host {}", host);
+        }
+        if let Some(target) = target {
+            print!(" --target {}", target);
+        }
+        if kind == Kind::Test {
+            for arg in self.builder.config.cmd.test_args() {
+                print!(" --test-args \"{}\"", arg);
+            }
+        }
+        println!();
+    }
+}

src/bootstrap/cache.rs

@@ -245,7 +245,7 @@ impl Cache {
         Cache(RefCell::new(HashMap::new()))
     }
 
-    pub fn put<S: Step>(&self, step: S, value: S::Output) {
+    pub(crate) fn put<S: Step>(&self, step: S, value: S::Output) {
         let mut cache = self.0.borrow_mut();
         let type_id = TypeId::of::<S>();
         let stepcache = cache
@@ -257,7 +257,7 @@ impl Cache {
         stepcache.insert(step, value);
     }
 
-    pub fn get<S: Step>(&self, step: &S) -> Option<S::Output> {
+    pub(crate) fn get<S: Step>(&self, step: &S) -> Option<S::Output> {
         let mut cache = self.0.borrow_mut();
         let type_id = TypeId::of::<S>();
         let stepcache = cache

src/bootstrap/check.rs

@@ -1,6 +1,6 @@
 //! Implementation of compiling the compiler and standard library, in "check"-based modes.
 
-use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
+use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step, StepInfo};
 use crate::cache::Interned;
 use crate::compile::{add_to_sysroot, run_cargo, rustc_cargo, rustc_cargo_env, std_cargo};
 use crate::config::TargetSelection;
@@ -71,6 +71,13 @@ impl Step for Std {
         run.builder.ensure(Std { target: run.target });
     }
 
+    fn info(step_info: &mut StepInfo<'_, '_, Self>) {
+        let step = step_info.step;
+        let builder = step_info.builder;
+        let compiler = builder.compiler(builder.top_stage, builder.config.build);
+        step_info.compiler(compiler).target(step.target).cmd(Kind::Check);
+    }
+
     fn run(self, builder: &Builder<'_>) {
         builder.update_submodule(&Path::new("library").join("stdarch"));
 
@@ -167,6 +174,13 @@ impl Step for Rustc {
         run.builder.ensure(Rustc { target: run.target });
     }
 
+    fn info(step_info: &mut StepInfo<'_, '_, Self>) {
+        let step = step_info.step;
+        let builder = step_info.builder;
+        let compiler = builder.compiler(builder.top_stage, builder.config.build);
+        step_info.compiler(compiler).target(step.target).cmd(Kind::Check);
+    }
+
     /// Builds the compiler.
     ///
     /// This will build the compiler for a particular stage of the build using

src/bootstrap/compile.rs

@@ -21,7 +21,7 @@ use filetime::FileTime;
 use serde::Deserialize;
 
 use crate::builder::Cargo;
-use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
+use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step, StepInfo};
 use crate::cache::{Interned, INTERNER};
 use crate::config::TargetSelection;
 use crate::dist;
@@ -54,12 +54,9 @@ impl Step for Std {
         });
     }
 
-    fn compiler(&self) -> Option<&Compiler> {
-        Some(&self.compiler)
-    }
-
-    fn target(&self) -> Option<&TargetSelection> {
-        Some(&self.target)
+    fn info(step_info: &mut StepInfo<'_, '_, Self>) {
+        let step = step_info.step;
+        step_info.compiler(&step.compiler).target(step.target).cmd(Kind::Build);
     }
 
     /// Builds the standard library.
@@ -527,14 +524,11 @@ impl Step for Rustc {
         });
     }
 
-    fn compiler(&self) -> Option<&Compiler> {
-        Some(&self.compiler)
+    fn info(step_info: &mut StepInfo<'_, '_, Self>) {
+        let step = step_info.step;
+        step_info.compiler(&step.compiler).target(step.target).cmd(Kind::Build);
     }
 
-    // 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

@@ -6,7 +6,7 @@ use std::process::{exit, Command};
 
 use build_helper::t;
 
-use crate::builder::{Builder, Cargo as CargoCommand, RunConfig, ShouldRun, Step};
+use crate::builder::{Builder, Cargo as CargoCommand, Kind, RunConfig, ShouldRun, Step, StepInfo};
 use crate::channel::GitInfo;
 use crate::compile;
 use crate::config::TargetSelection;
@@ -319,16 +319,9 @@ macro_rules! bootstrap_tool {
         impl Step for $name {
             type Output = PathBuf;
 
-            // 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 info(step_info: &mut StepInfo<'_, '_, Self>) {
+                let step = step_info.step;
+                step_info.compiler(&step.compiler).target(step.target).cmd(Kind::Build);
             }
 
             fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
@@ -607,16 +600,9 @@ impl Step for Cargo {
     const DEFAULT: bool = true;
     const ONLY_HOSTS: bool = true;
 
-    // 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 info(step_info: &mut StepInfo<'_, '_, Self>) {
+        let step = step_info.step;
+        step_info.compiler(&step.compiler).target(step.target).cmd(Kind::Build);
     }
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {

src/bootstrap/toolstate.rs

@@ -1,4 +1,4 @@
-use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
+use crate::builder::{Builder, RunConfig, ShouldRun, Step};
 use build_helper::t;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -141,10 +141,6 @@ 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