apply some nits and add coverage for downgraded_from

Signed-off-by: onur-ozkan <[email protected]>

Author: onur-ozkan

src/bootstrap/src/core/build_steps/clippy.rs

@@ -283,7 +283,7 @@ macro_rules! lint_any {
             }
 
             fn run(self, builder: &Builder<'_>) -> Self::Output {
-                let compiler = builder.compiler(builder.top_stage, builder.config.build, $mode == Mode::ToolRustc);
+                let compiler = builder.compiler(builder.top_stage, builder.config.build, builder.top_stage > 0 && $mode == Mode::ToolRustc);
                 let target = self.target;
 
                 builder.ensure(check::Rustc::new(target, builder).build_kind(Some(Kind::Check)));

src/bootstrap/src/core/build_steps/doc.rs

@@ -951,7 +951,7 @@ macro_rules! tool_doc {
                     // Rustdoc needs the rustc sysroot available to build.
                     // FIXME: is there a way to only ensure `check::Rustc` here? Last time I tried it failed
                     // with strange errors, but only on a full bors test ...
-                    let _ = builder.compiler(compiler.stage, target, false);
+                    let _ = builder.compiler(compiler.stage, target, true);
                 }
 
                 // Build cargo command.

src/bootstrap/src/core/build_steps/tool.rs

@@ -180,7 +180,7 @@ pub fn prepare_tool_cargo(
     extra_features: &[String],
 ) -> CargoCommand {
     // FIXME: remove stage check
-    if mode == Mode::ToolRustc && !compiler.is_downgraded_already() && compiler.stage != 0 {
+    if builder.top_stage > 0 && mode == Mode::ToolRustc && !compiler.is_downgraded_already() {
         // Similar to `compile::Assemble`, build with the previous stage's compiler. Otherwise
         // we'd have stageN/bin/rustc and stageN/bin/$tool_name be effectively different stage
         // compilers, which isn't what we want.
@@ -630,8 +630,8 @@ impl Step for Rustdoc {
         let compiler = self.compiler;
         let target = compiler.host;
 
-        if compiler.stage == 0 {
-            if !compiler.is_snapshot(builder) && !compiler.is_downgraded_already() {
+        if compiler.stage == 0 && !compiler.is_downgraded_already() {
+            if !compiler.is_snapshot(builder) {
                 panic!("rustdoc in stage 0 must be snapshot rustdoc");
             }
             return builder.initial_rustdoc.clone();

src/bootstrap/src/core/builder/mod.rs

@@ -1244,8 +1244,6 @@ impl<'a> Builder<'a> {
 
         // FIXME: remove stage check
         if stage > 0 && downgrade_for_rustc_tool {
-            assert!(stage > 0, "can't downgrade stage 0 compiler");
-
             self.ensure(compile::Std::new(compiler, host));
             // Similar to `compile::Assemble`, build with the previous stage's compiler. Otherwise
             // we'd have stageN/bin/rustc and stageN/bin/$tool_name be effectively different stage
@@ -1415,8 +1413,12 @@ impl<'a> Builder<'a> {
     }
 
     pub fn rustdoc(&self, mut compiler: Compiler) -> PathBuf {
-        // FIXME: remove stage check
-        if compiler.stage > 0 && !compiler.is_downgraded_already() {
+        if compiler.is_snapshot(self) && !compiler.is_downgraded_already() {
+            return self.initial_rustc.with_file_name(exe("rustdoc", compiler.host));
+        }
+
+        if !compiler.is_downgraded_already() {
+            assert!(compiler.stage > 0, "Can't use stage0 compiler for rustdoc");
             compiler.downgrade();
         }
 

src/bootstrap/src/lib.rs

@@ -106,8 +106,9 @@ impl std::hash::Hash for Compiler {
 
 impl PartialEq for Compiler {
     fn eq(&self, other: &Self) -> bool {
-        // FIXME: cover `downgraded_from` for test env
         self.stage == other.stage && self.host == other.host
+            // We have coverage for `downgraded_from` in our unit tests
+            && (!cfg!(test) || self.downgraded_from == other.downgraded_from)
     }
 }