Convert a bunch of steps to is_supported

Author: jyn514

src/bootstrap/src/core/build_steps/check.rs

@@ -13,7 +13,8 @@ use crate::core::build_steps::tool::{
     prepare_tool_cargo,
 };
 use crate::core::builder::{
-    self, Alias, Builder, Cargo, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
+    self, Alias, Builder, Cargo, Kind, RunConfig, ShouldRun, Step, StepMetadata, SupportedConfig,
+    Unsupported, crate_description,
 };
 use crate::core::config::TargetSelection;
 use crate::utils::build_stamp::{self, BuildStamp};
@@ -52,19 +53,30 @@ impl Step for Std {
         true
     }
 
-    fn make_run(run: RunConfig<'_>) {
-        if !run.builder.download_rustc() && run.builder.config.skip_std_check_if_no_download_rustc {
-            eprintln!(
-                "WARNING: `--skip-std-check-if-no-download-rustc` flag was passed and `rust.download-rustc` is not available. Skipping."
-            );
-            return;
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
+        let dummy_stamp = BuildStamp::new(Path::new("/dev/null"));
+
+        if !config.builder.download_rustc()
+            && config.builder.config.skip_std_check_if_no_download_rustc
+        {
+            return Err(Unsupported::Skip(
+                "`--skip-std-check-if-no-download-rustc` flag was passed and `rust.download-rustc` is not available".into(),
+                dummy_stamp,
+            ));
         }
 
-        if run.builder.config.compile_time_deps {
-            // libstd doesn't have any important build scripts and can't have any proc macros
-            return;
+        if config.builder.config.compile_time_deps {
+            return Err(Unsupported::Skip(
+                "libstd doesn't have any important build scripts and can't have any proc macros"
+                    .into(),
+                dummy_stamp,
+            ));
         }
 
+        Ok(())
+    }
+
+    fn make_run(run: RunConfig<'_>) {
         // Explicitly pass -p for all dependencies crates -- this will force cargo
         // to also check the tests/benches/examples for these crates, rather
         // than just the leaf crate.
@@ -626,13 +638,18 @@ impl Step for GccCodegenBackend {
         });
     }
 
-    fn run(self, builder: &Builder<'_>) {
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported> {
         // FIXME: remove once https://github.com/rust-lang/rust/issues/112393 is resolved
-        if builder.build.config.vendor {
-            println!("Skipping checking of `rustc_codegen_gcc` with vendoring enabled.");
-            return;
+        if config.builder.build.config.vendor {
+            Unsupported::skip(
+                "`rustc_codegen_gcc` does not currently support vendoring, see #112393",
+            )
+        } else {
+            Ok(())
         }
+    }
 
+    fn run(self, builder: &Builder<'_>) {
         let build_compiler = self.build_compiler.build_compiler();
         let target = self.target;
 

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

@@ -13,15 +13,15 @@
 //! 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::compile::{ArtifactKeepMode, run_cargo, rustc_cargo, std_cargo};
 use super::tool::{SourceType, prepare_tool_cargo};
 use crate::builder::{Builder, ShouldRun};
 use crate::core::build_steps::check::{CompilerForCheck, 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, StepMetadata, crate_description};
+use crate::core::builder::{
+    self, Alias, Kind, RunConfig, Step, StepMetadata, SupportedConfig, Unsupported,
+    crate_description,
+};
 use crate::utils::build_stamp::{self, BuildStamp};
 use crate::{Compiler, Mode, Subcommand, TargetSelection};
 
@@ -534,17 +534,20 @@ impl Step for CI {
         false
     }
 
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported> {
+        if config.builder.top_stage != 2 {
+            Unsupported::fatal("`x clippy ci` should always be executed with --stage 2")
+        } else {
+            Ok(())
+        }
+    }
+
     fn make_run(run: RunConfig<'_>) {
         let config = LintConfig::new(run.builder);
         run.builder.ensure(CI { target: run.target, config });
     }
 
     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.

src/bootstrap/src/core/build_steps/compile.rs

@@ -22,9 +22,9 @@ use tracing::span;
 use crate::core::build_steps::gcc::{Gcc, GccOutput, GccTargetPair};
 use crate::core::build_steps::tool::{RustcPrivateCompilers, SourceType, copy_lld_artifacts};
 use crate::core::build_steps::{dist, llvm};
-use crate::core::builder;
 use crate::core::builder::{
-    Builder, Cargo, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
+    self, Builder, Cargo, Kind, MakeOrEnsure, RunConfig, ShouldRun, Step, StepMetadata,
+    SupportedConfig, Unsupported, crate_description,
 };
 use crate::core::config::toml::target::DefaultLinuxLinkerOverride;
 use crate::core::config::{
@@ -901,6 +901,22 @@ impl Step for StartupObjects {
         });
     }
 
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
+        let target = match config.extra {
+            MakeOrEnsure::Run(run) => run.target,
+            MakeOrEnsure::Step(this) => this.target,
+        };
+        // Even though no longer necessary on x86_64, they are kept for now to
+        // avoid potential issues in downstream crates.
+        if target.is_windows_gnu() {
+            Ok(())
+        } else {
+            Unsupported::skip(
+                "outside windows-gnu platforms, startup objects are handled by the platform C compiler",
+            )
+        }
+    }
+
     /// Builds and prepare startup objects like rsbegin.o and rsend.o
     ///
     /// These are primarily used on Windows right now for linking executables/dlls.
@@ -910,11 +926,6 @@ impl Step for StartupObjects {
     fn run(self, builder: &Builder<'_>) -> Vec<(PathBuf, DependencyType)> {
         let for_compiler = self.compiler;
         let target = self.target;
-        // Even though no longer necessary on x86_64, they are kept for now to
-        // avoid potential issues in downstream crates.
-        if !target.is_windows_gnu() {
-            return vec![];
-        }
 
         let mut target_deps = vec![];
 
@@ -1024,6 +1035,8 @@ impl Step for Rustc {
     fn make_run(run: RunConfig<'_>) {
         // If only `compiler` was passed, do not run this step.
         // Instead the `Assemble` step will take care of compiling Rustc.
+        // NOTE: this doesn't use `is_supported` because the fact that `Rustc` is different
+        // from `Assemble` is an implementation detail.
         if run.builder.paths == vec![PathBuf::from("compiler")] {
             return;
         }

src/bootstrap/src/core/build_steps/dist.rs

@@ -29,14 +29,15 @@ use crate::core::build_steps::tool::{
 };
 use crate::core::build_steps::vendor::{VENDOR_DIR, Vendor};
 use crate::core::build_steps::{compile, llvm};
-use crate::core::builder::{Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata};
+use crate::core::builder::{
+    Builder, Kind, MakeOrEnsure, RunConfig, ShouldRun, Step, StepMetadata, SupportedConfig,
+    Unsupported,
+};
 use crate::core::config::{GccCiMode, TargetSelection};
 use crate::utils::build_stamp::{self, BuildStamp};
 use crate::utils::channel::{self, Info};
 use crate::utils::exec::{BootstrapCommand, command};
-use crate::utils::helpers::{
-    exe, is_dylib, move_file, t, target_supports_cranelift_backend, timeit,
-};
+use crate::utils::helpers::{exe, is_dylib, move_file, t, timeit};
 use crate::utils::tarball::{GeneratedTarball, OverlayKind, Tarball};
 use crate::{CodegenBackendKind, Compiler, DependencyType, FileType, LLVM_TOOLS, Mode, trace};
 
@@ -432,12 +433,20 @@ impl Step for Mingw {
         run.builder.ensure(Mingw { target: run.target });
     }
 
-    fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
-        let target = self.target;
-        if !target.contains("pc-windows-gnu") || !builder.config.dist_include_mingw_linker {
-            return None;
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
+        let target = match config.extra {
+            MakeOrEnsure::Run(run) => run.target,
+            MakeOrEnsure::Step(this) => this.target,
+        };
+        if !target.contains("pc-windows-gnu") || !config.builder.config.dist_include_mingw_linker {
+            Unsupported::skip("not a windows-gnu and `dist.include_mingw_linker` not enabled")
+        } else {
+            Ok(())
         }
+    }
 
+    fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
+        let target = self.target;
         let mut tarball = Tarball::new(builder, "rust-mingw", &target.triple);
         tarball.set_product_name("Rust MinGW");
 
@@ -1571,14 +1580,18 @@ impl Step for Miri {
         });
     }
 
-    fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
         // This prevents miri from being built for "dist" or "install"
         // on the stable/beta channels. It is a nightly-only tool and should
         // not be included.
-        if !builder.build.unstable_features() {
-            return None;
+        if !config.builder.unstable_features() {
+            Unsupported::skip("miri is nightly-only and is not shipped on beta or stable")
+        } else {
+            Ok(())
         }
+    }
 
+    fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
         let miri = builder.ensure(tool::Miri::from_compilers(self.compilers));
         let cargomiri = builder.ensure(tool::CargoMiri::from_compilers(self.compilers));
 
@@ -1637,7 +1650,7 @@ impl Step for CraneliftCodegenBackend {
         }
 
         let target = self.target;
-        if !target_supports_cranelift_backend(target) {
+        if !CodegenBackendKind::Cranelift.supports_target(target) {
             builder.info("target not supported by rustc_codegen_cranelift. skipping");
             return None;
         }

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

@@ -16,7 +16,8 @@ use crate::core::build_steps::tool::{
     self, RustcPrivateCompilers, SourceType, Tool, prepare_tool_cargo,
 };
 use crate::core::builder::{
-    self, Builder, Compiler, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
+    self, Builder, Compiler, Kind, MakeOrEnsure, RunConfig, ShouldRun, Step, StepMetadata,
+    SupportedConfig, Unsupported, crate_description,
 };
 use crate::core::config::{Config, TargetSelection};
 use crate::helpers::{submodule_path_of, symlink_dir, t, up_to_date};
@@ -652,12 +653,24 @@ impl Step for Std {
         builder.config.docs
     }
 
-    fn make_run(run: RunConfig<'_>) {
-        let crates = compile::std_crates_for_run_make(&run);
-        let target_is_no_std = run.builder.no_std(run.target).unwrap_or(false);
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
+        let crates_buf;
+        let (crates, target) = match config.extra {
+            MakeOrEnsure::Run(run) => {
+                crates_buf = compile::std_crates_for_run_make(run);
+                (&crates_buf, run.target)
+            }
+            MakeOrEnsure::Step(this) => (&this.crates, this.target),
+        };
+        let target_is_no_std = config.builder.no_std(target).unwrap_or(false);
         if crates.is_empty() && target_is_no_std {
-            return;
+            Unsupported::skip("no standard library crates supported for this no_std target")
+        } else {
+            Ok(())
         }
+    }
+
+    fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(Std {
             build_compiler: run.builder.compiler_for_std(run.builder.top_stage),
             target: run.target,
@@ -666,7 +679,7 @@ impl Step for Std {
             } else {
                 DocumentationFormat::Html
             },
-            crates,
+            crates: compile::std_crates_for_run_make(&run),
         });
     }
 

src/bootstrap/src/core/build_steps/llvm.rs

@@ -18,7 +18,9 @@ use build_helper::exit;
 use build_helper::git::PathFreshness;
 
 use crate::core::build_steps::llvm;
-use crate::core::builder::{Builder, RunConfig, ShouldRun, Step, StepMetadata};
+use crate::core::builder::{
+    Builder, MakeOrEnsure, RunConfig, ShouldRun, Step, StepMetadata, SupportedConfig, Unsupported,
+};
 use crate::core::config::{Config, TargetSelection};
 use crate::utils::build_stamp::{BuildStamp, generate_smart_stamp_hash};
 use crate::utils::exec::command;
@@ -1351,17 +1353,21 @@ impl Step for Sanitizers {
         run.alias("sanitizers")
     }
 
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
+        let compiler_rt_dir = config.builder.src.join("src/llvm-project/compiler-rt");
+        if !compiler_rt_dir.exists() {
+            Unsupported::skip("need llvm/compiler-rt checked out on disk to build sanitizers")
+        } else {
+            Ok(())
+        }
+    }
+
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(Sanitizers { target: run.target });
     }
 
     /// Builds sanitizer runtime libraries.
     fn run(self, builder: &Builder<'_>) -> Self::Output {
-        let compiler_rt_dir = builder.src.join("src/llvm-project/compiler-rt");
-        if !compiler_rt_dir.exists() {
-            return Vec::new();
-        }
-
         let out_dir = builder.native_dir(self.target).join("sanitizers");
         let runtimes = supported_sanitizers(&out_dir, self.target, &builder.config.channel);
 
@@ -1398,6 +1404,7 @@ impl Step for Sanitizers {
         t!(stamp.remove());
         let _time = helpers::timeit(builder);
 
+        let compiler_rt_dir = builder.src.join("src/llvm-project/compiler-rt");
         let mut cfg = cmake::Config::new(&compiler_rt_dir);
         cfg.profile("Release");
         cfg.define("CMAKE_C_COMPILER_TARGET", self.target.triple);
@@ -1545,12 +1552,22 @@ impl Step for CrtBeginEnd {
         run.path("src/llvm-project/compiler-rt/lib/crt")
     }
 
-    fn make_run(run: RunConfig<'_>) {
-        if run.target.needs_crt_begin_end() {
-            run.builder.ensure(CrtBeginEnd { target: run.target });
+    fn is_supported(config: SupportedConfig<'_, Self>) -> Result<(), Unsupported<Self::Output>> {
+        let target = match config.extra {
+            MakeOrEnsure::Run(run) => run.target,
+            MakeOrEnsure::Step(this) => this.target,
+        };
+        if !target.needs_crt_begin_end() {
+            Unsupported::skip("no self-contained C runtime necessary for this target")
+        } else {
+            Ok(())
         }
     }
 
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(CrtBeginEnd { target: run.target });
+    }
+
     /// Build crtbegin.o/crtend.o for musl target.
     fn run(self, builder: &Builder<'_>) -> Self::Output {
         builder.require_submodule(