Auto merge of #145131 - Kobzol:bootstrap-clippy, r=jieyouxu

Enforce in bootstrap that clippy must have stage at least 1

This mostly piggybacks on the previous `x check` [rework](https://github.com/rust-lang/rust/pull/143048).

The new "rules" follow the new staging logic. So `x clippy <foo>` lints `foo` using stage0 Clippy. `x clippy --stage 2 <foo>` lints `foo` using stage1 Clippy (which is built from in-tree sources).

I had to fix some latent issues with `prepare_compiler_for_check` along the way.

Checking `rustc_private` tools should now check less compiler crates (or rather not check compiler examples/tests/etc.), potentially speeding it up slightly.

I also had to make some manual adjustments to `x clippy ci` so that it doesn't do needless work.

r? `@jieyouxu`

8 files changed, 431 insertions, 144 deletions

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 0cbf8f55e99..6d393446d45 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -30,10 +30,6 @@ pub struct Std {
 
 impl Std {
     const CRATE_OR_DEPS: &[&str] = &["sysroot", "coretests", "alloctests"];
-
-    pub fn new(build_compiler: Compiler, target: TargetSelection) -> Self {
-        Self { build_compiler, target, crates: vec![] }
-    }
 }
 
 impl Step for Std {
@@ -168,12 +164,8 @@ pub struct Rustc {
 }
 
 impl Rustc {
-    pub fn new(builder: &Builder<'_>, build_compiler: Compiler, target: TargetSelection) -> Self {
-        let crates = builder
-            .in_tree_crates("rustc-main", Some(target))
-            .into_iter()
-            .map(|krate| krate.name.to_string())
-            .collect();
+    pub fn new(builder: &Builder<'_>, target: TargetSelection, crates: Vec<String>) -> Self {
+        let build_compiler = prepare_compiler_for_check(builder, target, Mode::Rustc);
         Self { build_compiler, target, crates }
     }
 }
@@ -189,11 +181,7 @@ impl Step for Rustc {
 
     fn make_run(run: RunConfig<'_>) {
         let crates = run.make_run_crates(Alias::Compiler);
-        run.builder.ensure(Rustc {
-            target: run.target,
-            build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Rustc),
-            crates,
-        });
+        run.builder.ensure(Rustc::new(run.builder, run.target, crates));
     }
 
     /// Check the compiler.
@@ -207,15 +195,6 @@ impl Step for Rustc {
         let build_compiler = self.build_compiler;
         let target = self.target;
 
-        // Build host std for compiling build scripts
-        builder.std(build_compiler, build_compiler.host);
-
-        // Build target std so that the checked rustc can link to it during the check
-        // FIXME: maybe we can a way to only do a check of std here?
-        // But for that we would have to copy the stdlib rmetas to the sysroot of the build
-        // compiler, which conflicts with std rlibs, if we also build std.
-        builder.std(build_compiler, target);
-
         let mut cargo = builder::Cargo::new(
             builder,
             build_compiler,
@@ -253,12 +232,18 @@ impl Step for Rustc {
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
-        Some(StepMetadata::check("rustc", self.target).built_by(self.build_compiler))
+        let metadata = StepMetadata::check("rustc", self.target).built_by(self.build_compiler);
+        let metadata = if self.crates.is_empty() {
+            metadata
+        } else {
+            metadata.with_metadata(format!("({} crates)", self.crates.len()))
+        };
+        Some(metadata)
     }
 }
 
 /// Prepares a compiler that will check something with the given `mode`.
-fn prepare_compiler_for_check(
+pub fn prepare_compiler_for_check(
     builder: &Builder<'_>,
     target: TargetSelection,
     mode: Mode,
@@ -289,11 +274,13 @@ fn prepare_compiler_for_check(
             build_compiler
         }
         Mode::ToolRustc | Mode::Codegen => {
-            // FIXME: this is a hack, see description of Mode::Rustc below
-            let stage = if host == target { builder.top_stage - 1 } else { builder.top_stage };
-            // When checking tool stage N, we check it with compiler stage N-1
-            let build_compiler = builder.compiler(stage, host);
-            builder.ensure(Rustc::new(builder, build_compiler, target));
+            // Check Rustc to produce the required rmeta artifacts for rustc_private, and then
+            // return the build compiler that was used to check rustc.
+            // We do not need to check examples/tests/etc. of Rustc for rustc_private, so we pass
+            // an empty set of crates, which will avoid using `cargo -p`.
+            let check = Rustc::new(builder, target, vec![]);
+            let build_compiler = check.build_compiler;
+            builder.ensure(check);
             build_compiler
         }
         Mode::Rustc => {
@@ -305,7 +292,18 @@ fn prepare_compiler_for_check(
             // FIXME: remove this and either fix cross-compilation check on stage 2 (which has a
             // myriad of other problems) or disable cross-checking on stage 1.
             let stage = if host == target { builder.top_stage - 1 } else { builder.top_stage };
-            builder.compiler(stage, host)
+            let build_compiler = builder.compiler(stage, host);
+
+            // Build host std for compiling build scripts
+            builder.std(build_compiler, build_compiler.host);
+
+            // Build target std so that the checked rustc can link to it during the check
+            // FIXME: maybe we can a way to only do a check of std here?
+            // But for that we would have to copy the stdlib rmetas to the sysroot of the build
+            // compiler, which conflicts with std rlibs, if we also build std.
+            builder.std(build_compiler, target);
+
+            build_compiler
         }
         Mode::Std => {
             // When checking std stage N, we want to do it with the stage N compiler
diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index 4d734fe5c66..23d9a032eb9 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -1,14 +1,29 @@
 //! Implementation of running clippy on the compiler, standard library and various tools.
+//!
+//! This serves a double purpose:
+//! - The first is to run Clippy itself on in-tree code, in order to test and dogfood it.
+//! - The second is to actually lint the in-tree codebase on CI, with a hard-coded set of rules,
+//!   which is performed by the `x clippy ci` command.
+//!
+//! In order to prepare a build compiler for running clippy, use the
+//! [prepare_compiler_for_check] function. That prepares a
+//! compiler and a standard library
+//! for running Clippy. The second part (actually building Clippy) is performed inside
+//! [Builder::cargo_clippy_cmd]. It would be nice if this was more explicit, and we actually had
+//! to pass a prebuilt Clippy from the outside when running `cargo clippy`, but that would be
+//! (as usual) a massive undertaking/refactoring.
+
+use build_helper::exit;
 
-use super::check;
 use super::compile::{run_cargo, rustc_cargo, std_cargo};
 use super::tool::{SourceType, prepare_tool_cargo};
 use crate::builder::{Builder, ShouldRun};
+use crate::core::build_steps::check::prepare_compiler_for_check;
 use crate::core::build_steps::compile::std_crates_for_run_make;
 use crate::core::builder;
-use crate::core::builder::{Alias, Kind, RunConfig, Step, crate_description};
+use crate::core::builder::{Alias, Kind, RunConfig, Step, StepMetadata, crate_description};
 use crate::utils::build_stamp::{self, BuildStamp};
-use crate::{Mode, Subcommand, TargetSelection};
+use crate::{Compiler, Mode, Subcommand, TargetSelection};
 
 /// Disable the most spammy clippy lints
 const IGNORED_RULES_FOR_STD_AND_RUSTC: &[&str] = &[
@@ -121,12 +136,38 @@ impl LintConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Std {
-    pub target: TargetSelection,
+    build_compiler: Compiler,
+    target: TargetSelection,
     config: LintConfig,
     /// Whether to lint only a subset of crates.
     crates: Vec<String>,
 }
 
+impl Std {
+    fn new(
+        builder: &Builder<'_>,
+        target: TargetSelection,
+        config: LintConfig,
+        crates: Vec<String>,
+    ) -> Self {
+        Self {
+            build_compiler: builder.compiler(builder.top_stage, builder.host_target),
+            target,
+            config,
+            crates,
+        }
+    }
+
+    fn from_build_compiler(
+        build_compiler: Compiler,
+        target: TargetSelection,
+        config: LintConfig,
+        crates: Vec<String>,
+    ) -> Self {
+        Self { build_compiler, target, config, crates }
+    }
+}
+
 impl Step for Std {
     type Output = ();
     const DEFAULT: bool = true;
@@ -138,12 +179,12 @@ impl Step for Std {
     fn make_run(run: RunConfig<'_>) {
         let crates = std_crates_for_run_make(&run);
         let config = LintConfig::new(run.builder);
-        run.builder.ensure(Std { target: run.target, config, crates });
+        run.builder.ensure(Std::new(run.builder, run.target, config, crates));
     }
 
     fn run(self, builder: &Builder<'_>) {
         let target = self.target;
-        let build_compiler = builder.compiler(builder.top_stage, builder.config.host_target);
+        let build_compiler = self.build_compiler;
 
         let mut cargo = builder::Cargo::new(
             builder,
@@ -178,16 +219,41 @@ impl Step for Std {
             false,
         );
     }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::clippy("std", self.target).built_by(self.build_compiler))
+    }
 }
 
+/// Lints the compiler.
+///
+/// This will build Clippy with the `build_compiler` and use it to lint
+/// in-tree rustc.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Rustc {
-    pub target: TargetSelection,
+    build_compiler: Compiler,
+    target: TargetSelection,
     config: LintConfig,
     /// Whether to lint only a subset of crates.
     crates: Vec<String>,
 }
 
+impl Rustc {
+    fn new(
+        builder: &Builder<'_>,
+        target: TargetSelection,
+        config: LintConfig,
+        crates: Vec<String>,
+    ) -> Self {
+        Self {
+            build_compiler: prepare_compiler_for_check(builder, target, Mode::Rustc),
+            target,
+            config,
+            crates,
+        }
+    }
+}
+
 impl Step for Rustc {
     type Output = ();
     const ONLY_HOSTS: bool = true;
@@ -198,33 +264,16 @@ impl Step for Rustc {
     }
 
     fn make_run(run: RunConfig<'_>) {
+        let builder = run.builder;
         let crates = run.make_run_crates(Alias::Compiler);
         let config = LintConfig::new(run.builder);
-        run.builder.ensure(Rustc { target: run.target, config, crates });
+        run.builder.ensure(Rustc::new(builder, run.target, config, crates));
     }
 
-    /// Lints the compiler.
-    ///
-    /// This will lint the compiler for a particular stage of the build using
-    /// the `compiler` targeting the `target` architecture.
     fn run(self, builder: &Builder<'_>) {
-        let build_compiler = builder.compiler(builder.top_stage, builder.config.host_target);
+        let build_compiler = self.build_compiler;
         let target = self.target;
 
-        if !builder.download_rustc() {
-            if build_compiler.stage != 0 {
-                // If we're not in stage 0, then we won't have a std from the beta
-                // compiler around. That means we need to make sure there's one in
-                // the sysroot for the compiler to find. Otherwise, we're going to
-                // fail when building crates that need to generate code (e.g., build
-                // scripts and their dependencies).
-                builder.std(build_compiler, build_compiler.host);
-                builder.std(build_compiler, target);
-            } else {
-                builder.ensure(check::Std::new(build_compiler, target));
-            }
-        }
-
         let mut cargo = builder::Cargo::new(
             builder,
             build_compiler,
@@ -261,11 +310,85 @@ impl Step for Rustc {
             false,
         );
     }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::clippy("rustc", self.target).built_by(self.build_compiler))
+    }
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct CodegenGcc {
+    build_compiler: Compiler,
+    target: TargetSelection,
+    config: LintConfig,
+}
+
+impl CodegenGcc {
+    fn new(builder: &Builder<'_>, target: TargetSelection, config: LintConfig) -> Self {
+        Self {
+            build_compiler: prepare_compiler_for_check(builder, target, Mode::Codegen),
+            target,
+            config,
+        }
+    }
+}
+
+impl Step for CodegenGcc {
+    type Output = ();
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.alias("rustc_codegen_gcc")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        let builder = run.builder;
+        let config = LintConfig::new(builder);
+        builder.ensure(CodegenGcc::new(builder, run.target, config));
+    }
+
+    fn run(self, builder: &Builder<'_>) -> Self::Output {
+        let build_compiler = self.build_compiler;
+        let target = self.target;
+
+        let cargo = prepare_tool_cargo(
+            builder,
+            build_compiler,
+            Mode::Codegen,
+            target,
+            Kind::Clippy,
+            "compiler/rustc_codegen_gcc",
+            SourceType::InTree,
+            &[],
+        );
+
+        let _guard =
+            builder.msg(Kind::Clippy, "rustc_codegen_gcc", Mode::ToolRustc, build_compiler, target);
+
+        let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, Mode::Codegen, target))
+            .with_prefix("rustc_codegen_gcc-check");
+
+        run_cargo(
+            builder,
+            cargo,
+            lint_args(builder, &self.config, &[]),
+            &stamp,
+            vec![],
+            true,
+            false,
+        );
+    }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::clippy("rustc_codegen_gcc", self.target).built_by(self.build_compiler))
+    }
 }
 
 macro_rules! lint_any {
     ($(
-        $name:ident, $path:expr, $readable_name:expr
+        $name:ident,
+        $path:expr,
+        $readable_name:expr,
+        $mode:expr
         $(,lint_by_default = $lint_by_default:expr)*
         ;
     )+) => {
@@ -273,7 +396,8 @@ macro_rules! lint_any {
 
         #[derive(Debug, Clone, Hash, PartialEq, Eq)]
         pub struct $name {
-            pub target: TargetSelection,
+            build_compiler: Compiler,
+            target: TargetSelection,
             config: LintConfig,
         }
 
@@ -288,23 +412,19 @@ macro_rules! lint_any {
             fn make_run(run: RunConfig<'_>) {
                 let config = LintConfig::new(run.builder);
                 run.builder.ensure($name {
+                    build_compiler: prepare_compiler_for_check(run.builder, run.target, $mode),
                     target: run.target,
                     config,
                 });
             }
 
             fn run(self, builder: &Builder<'_>) -> Self::Output {
-                let build_compiler = builder.compiler(builder.top_stage, builder.config.host_target);
+                let build_compiler = self.build_compiler;
                 let target = self.target;
-
-                if !builder.download_rustc() {
-                    builder.ensure(check::Rustc::new(builder, build_compiler, target));
-                };
-
                 let cargo = prepare_tool_cargo(
                     builder,
                     build_compiler,
-                    Mode::ToolRustc,
+                    $mode,
                     target,
                     Kind::Clippy,
                     $path,
@@ -315,13 +435,13 @@ macro_rules! lint_any {
                 let _guard = builder.msg(
                     Kind::Clippy,
                     $readable_name,
-                    Mode::ToolRustc,
+                    $mode,
                     build_compiler,
                     target,
                 );
 
                 let stringified_name = stringify!($name).to_lowercase();
-                let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, Mode::ToolRustc, target))
+                let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, $mode, target))
                     .with_prefix(&format!("{}-check", stringified_name));
 
                 run_cargo(
@@ -334,38 +454,44 @@ macro_rules! lint_any {
                     false,
                 );
             }
+
+            fn metadata(&self) -> Option<StepMetadata> {
+                Some(StepMetadata::clippy($readable_name, self.target).built_by(self.build_compiler))
+            }
         }
         )+
     }
 }
 
+// Note: we use ToolTarget instead of ToolBootstrap here, to allow linting in-tree host tools
+// using the in-tree Clippy. Because Mode::ToolBootstrap would always use stage 0 rustc/Clippy.
 lint_any!(
-    Bootstrap, "src/bootstrap", "bootstrap";
-    BuildHelper, "src/build_helper", "build_helper";
-    BuildManifest, "src/tools/build-manifest", "build-manifest";
-    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri";
-    Clippy, "src/tools/clippy", "clippy";
-    CollectLicenseMetadata, "src/tools/collect-license-metadata", "collect-license-metadata";
-    CodegenGcc, "compiler/rustc_codegen_gcc", "rustc-codegen-gcc";
-    Compiletest, "src/tools/compiletest", "compiletest";
-    CoverageDump, "src/tools/coverage-dump", "coverage-dump";
-    Jsondocck, "src/tools/jsondocck", "jsondocck";
-    Jsondoclint, "src/tools/jsondoclint", "jsondoclint";
-    LintDocs, "src/tools/lint-docs", "lint-docs";
-    LlvmBitcodeLinker, "src/tools/llvm-bitcode-linker", "llvm-bitcode-linker";
-    Miri, "src/tools/miri", "miri";
-    MiroptTestTools, "src/tools/miropt-test-tools", "miropt-test-tools";
-    OptDist, "src/tools/opt-dist", "opt-dist";
-    RemoteTestClient, "src/tools/remote-test-client", "remote-test-client";
-    RemoteTestServer, "src/tools/remote-test-server", "remote-test-server";
-    RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer";
-    Rustdoc, "src/librustdoc", "clippy";
-    Rustfmt, "src/tools/rustfmt", "rustfmt";
-    RustInstaller, "src/tools/rust-installer", "rust-installer";
-    Tidy, "src/tools/tidy", "tidy";
-    TestFloatParse, "src/tools/test-float-parse", "test-float-parse";
+    Bootstrap, "src/bootstrap", "bootstrap", Mode::ToolTarget;
+    BuildHelper, "src/build_helper", "build_helper", Mode::ToolTarget;
+    BuildManifest, "src/tools/build-manifest", "build-manifest", Mode::ToolTarget;
+    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", Mode::ToolRustc;
+    Clippy, "src/tools/clippy", "clippy", Mode::ToolRustc;
+    CollectLicenseMetadata, "src/tools/collect-license-metadata", "collect-license-metadata", Mode::ToolTarget;
+    Compiletest, "src/tools/compiletest", "compiletest", Mode::ToolTarget;
+    CoverageDump, "src/tools/coverage-dump", "coverage-dump", Mode::ToolTarget;
+    Jsondocck, "src/tools/jsondocck", "jsondocck", Mode::ToolTarget;
+    Jsondoclint, "src/tools/jsondoclint", "jsondoclint", Mode::ToolTarget;
+    LintDocs, "src/tools/lint-docs", "lint-docs", Mode::ToolTarget;
+    LlvmBitcodeLinker, "src/tools/llvm-bitcode-linker", "llvm-bitcode-linker", Mode::ToolTarget;
+    Miri, "src/tools/miri", "miri", Mode::ToolRustc;
+    MiroptTestTools, "src/tools/miropt-test-tools", "miropt-test-tools", Mode::ToolTarget;
+    OptDist, "src/tools/opt-dist", "opt-dist", Mode::ToolTarget;
+    RemoteTestClient, "src/tools/remote-test-client", "remote-test-client", Mode::ToolTarget;
+    RemoteTestServer, "src/tools/remote-test-server", "remote-test-server", Mode::ToolTarget;
+    RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer", Mode::ToolRustc;
+    Rustdoc, "src/librustdoc", "clippy", Mode::ToolRustc;
+    Rustfmt, "src/tools/rustfmt", "rustfmt", Mode::ToolRustc;
+    RustInstaller, "src/tools/rust-installer", "rust-installer", Mode::ToolTarget;
+    Tidy, "src/tools/tidy", "tidy", Mode::ToolTarget;
+    TestFloatParse, "src/tools/test-float-parse", "test-float-parse", Mode::ToolStd;
 );
 
+/// Runs Clippy on in-tree sources of selected projects using in-tree CLippy.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CI {
     target: TargetSelection,
@@ -386,7 +512,21 @@ impl Step for CI {
     }
 
     fn run(self, builder: &Builder<'_>) -> Self::Output {
+        if builder.top_stage != 2 {
+            eprintln!("ERROR: `x clippy ci` should always be executed with --stage 2");
+            exit!(1);
+        }
+
+        // We want to check in-tree source using in-tree clippy. However, if we naively did
+        // a stage 2 `x clippy ci`, it would *build* a stage 2 rustc, in order to lint stage 2
+        // std, which is wasteful.
+        // So we want to lint stage 2 [bootstrap/rustc/...], but only stage 1 std rustc_codegen_gcc.
+        // We thus construct the compilers in this step manually, to optimize the number of
+        // steps that get built.
+
         builder.ensure(Bootstrap {
+            // This will be the stage 1 compiler
+            build_compiler: prepare_compiler_for_check(builder, self.target, Mode::ToolTarget),
             target: self.target,
             config: self.config.merge(&LintConfig {
                 allow: vec![],
@@ -395,6 +535,7 @@ impl Step for CI {
                 forbid: vec![],
             }),
         });
+
         let library_clippy_cfg = LintConfig {
             allow: vec!["clippy::all".into()],
             warn: vec![],
@@ -412,11 +553,13 @@ impl Step for CI {
             ],
             forbid: vec![],
         };
-        builder.ensure(Std {
-            target: self.target,
-            config: self.config.merge(&library_clippy_cfg),
-            crates: vec![],
-        });
+        builder.ensure(Std::from_build_compiler(
+            // This will be the stage 1 compiler, to avoid building rustc stage 2 just to lint std
+            builder.compiler(1, self.target),
+            self.target,
+            self.config.merge(&library_clippy_cfg),
+            vec![],
+        ));
 
         let compiler_clippy_cfg = LintConfig {
             allow: vec!["clippy::all".into()],
@@ -437,11 +580,13 @@ impl Step for CI {
             ],
             forbid: vec![],
         };
-        builder.ensure(Rustc {
-            target: self.target,
-            config: self.config.merge(&compiler_clippy_cfg),
-            crates: vec![],
-        });
+        // This will lint stage 2 rustc using stage 1 Clippy
+        builder.ensure(Rustc::new(
+            builder,
+            self.target,
+            self.config.merge(&compiler_clippy_cfg),
+            vec![],
+        ));
 
         let rustc_codegen_gcc = LintConfig {
             allow: vec![],
@@ -449,9 +594,11 @@ impl Step for CI {
             deny: vec!["warnings".into()],
             forbid: vec![],
         };
-        builder.ensure(CodegenGcc {
-            target: self.target,
-            config: self.config.merge(&rustc_codegen_gcc),
-        });
+        // This will check stage 2 rustc
+        builder.ensure(CodegenGcc::new(
+            builder,
+            self.target,
+            self.config.merge(&rustc_codegen_gcc),
+        ));
     }
 }
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index de4b941ac90..54bf1842ab3 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -160,6 +160,10 @@ impl StepMetadata {
         Self::new(name, target, Kind::Check)
     }
 
+    pub fn clippy(name: &str, target: TargetSelection) -> Self {
+        Self::new(name, target, Kind::Clippy)
+    }
+
     pub fn doc(name: &str, target: TargetSelection) -> Self {
         Self::new(name, target, Kind::Doc)
     }
@@ -1552,35 +1556,6 @@ You have to build a stage1 compiler for `{}` first, and then use it to build a s
         self.ensure(tool::Rustdoc { target_compiler })
     }
 
-    pub fn cargo_clippy_cmd(&self, run_compiler: Compiler) -> BootstrapCommand {
-        if run_compiler.stage == 0 {
-            let cargo_clippy = self
-                .config
-                .initial_cargo_clippy
-                .clone()
-                .unwrap_or_else(|| self.build.config.download_clippy());
-
-            let mut cmd = command(cargo_clippy);
-            cmd.env("CARGO", &self.initial_cargo);
-            return cmd;
-        }
-
-        // FIXME: double check that `run_compiler`'s stage is what we want to use
-        let compilers =
-            RustcPrivateCompilers::new(self, run_compiler.stage, self.build.host_target);
-        assert_eq!(run_compiler, compilers.target_compiler());
-
-        let _ = self.ensure(tool::Clippy::from_compilers(compilers));
-        let cargo_clippy = self.ensure(tool::CargoClippy::from_compilers(compilers));
-        let mut dylib_path = helpers::dylib_path();
-        dylib_path.insert(0, self.sysroot(run_compiler).join("lib"));
-
-        let mut cmd = command(cargo_clippy.tool_path);
-        cmd.env(helpers::dylib_path_var(), env::join_paths(&dylib_path).unwrap());
-        cmd.env("CARGO", &self.initial_cargo);
-        cmd
-    }
-
     pub fn cargo_miri_cmd(&self, run_compiler: Compiler) -> BootstrapCommand {
         assert!(run_compiler.stage > 0, "miri can not be invoked at stage 0");
 
@@ -1607,6 +1582,37 @@ You have to build a stage1 compiler for `{}` first, and then use it to build a s
         cmd
     }
 
+    /// Create a Cargo command for running Clippy.
+    /// The used Clippy is (or in the case of stage 0, already was) built using `build_compiler`.
+    pub fn cargo_clippy_cmd(&self, build_compiler: Compiler) -> BootstrapCommand {
+        if build_compiler.stage == 0 {
+            let cargo_clippy = self
+                .config
+                .initial_cargo_clippy
+                .clone()
+                .unwrap_or_else(|| self.build.config.download_clippy());
+
+            let mut cmd = command(cargo_clippy);
+            cmd.env("CARGO", &self.initial_cargo);
+            return cmd;
+        }
+
+        // If we're linting something with build_compiler stage N, we want to build Clippy stage N
+        // and use that to lint it. That is why we use the `build_compiler` as the target compiler
+        // for RustcPrivateCompilers. We will use build compiler stage N-1 to build Clippy stage N.
+        let compilers = RustcPrivateCompilers::from_target_compiler(self, build_compiler);
+
+        let _ = self.ensure(tool::Clippy::from_compilers(compilers));
+        let cargo_clippy = self.ensure(tool::CargoClippy::from_compilers(compilers));
+        let mut dylib_path = helpers::dylib_path();
+        dylib_path.insert(0, self.sysroot(build_compiler).join("lib"));
+
+        let mut cmd = command(cargo_clippy.tool_path);
+        cmd.env(helpers::dylib_path_var(), env::join_paths(&dylib_path).unwrap());
+        cmd.env("CARGO", &self.initial_cargo);
+        cmd
+    }
+
     pub fn rustdoc_cmd(&self, compiler: Compiler) -> BootstrapCommand {
         let mut cmd = command(self.bootstrap_out.join("rustdoc"));
         cmd.env("RUSTC_STAGE", compiler.stage.to_string())
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 32d191c4265..9ba57542549 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1515,6 +1515,7 @@ mod snapshot {
             ctx.config("check")
                 .path("compiler")
                 .render_steps(), @r"
+        [check] rustc 0 <host> -> rustc 1 <host> (73 crates)
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
         [check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
@@ -1527,9 +1528,7 @@ mod snapshot {
         insta::assert_snapshot!(
             ctx.config("check")
                 .path("rustc")
-                .render_steps(), @r"
-        [check] rustc 0 <host> -> rustc 1 <host>
-        ");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (1 crates)");
     }
 
     #[test]
@@ -1547,6 +1546,7 @@ mod snapshot {
                 .path("compiler")
                 .stage(1)
                 .render_steps(), @r"
+        [check] rustc 0 <host> -> rustc 1 <host> (73 crates)
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
         [check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
@@ -1564,6 +1564,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
+        [check] rustc 1 <host> -> rustc 2 <host> (73 crates)
         [check] rustc 1 <host> -> rustc 2 <host>
         [check] rustc 1 <host> -> rustc_codegen_cranelift 2 <host>
         [check] rustc 1 <host> -> rustc_codegen_gcc 2 <host>
@@ -1582,6 +1583,7 @@ mod snapshot {
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
+        [check] rustc 1 <host> -> rustc 2 <target1> (73 crates)
         [check] rustc 1 <host> -> rustc 2 <target1>
         [check] rustc 1 <host> -> Rustdoc 2 <target1>
         [check] rustc 1 <host> -> rustc_codegen_cranelift 2 <target1>
@@ -1678,6 +1680,7 @@ mod snapshot {
                 .paths(&["library", "compiler"])
                 .args(&args)
                 .render_steps(), @r"
+        [check] rustc 0 <host> -> rustc 1 <host> (73 crates)
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
         [check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
@@ -2065,6 +2068,130 @@ mod snapshot {
         [doc] rustc 1 <host> -> reference (book) 2 <host>
         ");
     }
+
+    #[test]
+    fn clippy_ci() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("ci")
+                .stage(2)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 0 <host> -> clippy-driver 1 <host>
+        [build] rustc 0 <host> -> cargo-clippy 1 <host>
+        [clippy] rustc 1 <host> -> bootstrap 2 <host>
+        [clippy] rustc 1 <host> -> std 1 <host>
+        [clippy] rustc 1 <host> -> rustc 2 <host>
+        [check] rustc 1 <host> -> rustc 2 <host>
+        [clippy] rustc 1 <host> -> rustc_codegen_gcc 2 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_compiler_stage1() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("compiler")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [clippy] rustc 0 <host> -> rustc 1 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_compiler_stage2() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("compiler")
+                .stage(2)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 0 <host> -> clippy-driver 1 <host>
+        [build] rustc 0 <host> -> cargo-clippy 1 <host>
+        [clippy] rustc 1 <host> -> rustc 2 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_std_stage1() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("std")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> clippy-driver 1 <host>
+        [build] rustc 0 <host> -> cargo-clippy 1 <host>
+        [clippy] rustc 1 <host> -> std 1 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_std_stage2() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("std")
+                .stage(2)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 1 <host> -> clippy-driver 2 <host>
+        [build] rustc 1 <host> -> cargo-clippy 2 <host>
+        [clippy] rustc 2 <host> -> std 2 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_miri_stage1() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("miri")
+                .stage(1)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [check] rustc 0 <host> -> rustc 1 <host>
+        [clippy] rustc 0 <host> -> miri 1 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_miri_stage2() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("miri")
+                .stage(2)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [check] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 0 <host> -> clippy-driver 1 <host>
+        [build] rustc 0 <host> -> cargo-clippy 1 <host>
+        [clippy] rustc 1 <host> -> miri 2 <host>
+        ");
+    }
+
+    #[test]
+    fn clippy_bootstrap() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("clippy")
+                .path("bootstrap")
+                .render_steps(), @"[clippy] rustc 0 <host> -> bootstrap 1 <host>");
+    }
 }
 
 struct ExecutedSteps {
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index a656927b1f6..9ced81e1e28 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1375,6 +1375,10 @@ impl Config {
                 eprintln!("ERROR: cannot document anything on stage 0. Use at least stage 1.");
                 exit!(1);
             }
+            (0, Subcommand::Clippy { .. }) => {
+                eprintln!("ERROR: cannot run clippy on stage 0. Use at least stage 1.");
+                exit!(1);
+            }
             _ => {}
         }
 
diff --git a/src/bootstrap/src/utils/build_stamp.rs b/src/bootstrap/src/utils/build_stamp.rs
index bd4eb790ae5..6c79385190e 100644
--- a/src/bootstrap/src/utils/build_stamp.rs
+++ b/src/bootstrap/src/utils/build_stamp.rs
@@ -146,13 +146,13 @@ pub fn libstd_stamp(
 }
 
 /// Cargo's output path for librustc in a given stage, compiled by a particular
-/// compiler for the specified target.
+/// `build_compiler` for the specified target.
 pub fn librustc_stamp(
     builder: &Builder<'_>,
-    compiler: Compiler,
+    build_compiler: Compiler,
     target: TargetSelection,
 ) -> BuildStamp {
-    BuildStamp::new(&builder.cargo_out(compiler, Mode::Rustc, target)).with_prefix("librustc")
+    BuildStamp::new(&builder.cargo_out(build_compiler, Mode::Rustc, target)).with_prefix("librustc")
 }
 
 /// Computes a hash representing the state of a repository/submodule and additional input.
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index cd7fba39a84..b454a8ddefb 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -501,4 +501,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Warning,
         summary: "The names of stageN directories in the build directory have been consolidated with the new (post-stage-0-redesign) staging scheme. Some tools and binaries might be located in a different build directory than before.",
     },
+    ChangeInfo {
+        change_id: 145131,
+        severity: ChangeSeverity::Warning,
+        summary: "It is no longer possible to `x clippy` with stage 0. All clippy commands have to be on stage 1+.",
+    },
 ];
diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
index 6fea2437276..8073b8efb46 100644
--- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
@@ -28,7 +28,7 @@ RUN sh /scripts/sccache.sh
 
 ENV SCRIPT \
         python3 ../x.py check && \
-        python3 ../x.py clippy ci && \
+        python3 ../x.py clippy ci --stage 2 && \
         python3 ../x.py test --stage 1 core alloc std test proc_macro && \
         python3 ../x.py test --stage 1 src/tools/compiletest && \
         python3 ../x.py doc bootstrap && \