Introduce first-class compiletest-force-stage0 override

Instead of the ad-hoc `COMPILETEST_FORCE_STAGE0` env var. However,
explicitly do not test this configuration under CI, as tests are most
certainly not guaranteed to pass against stage 0 (compiler, library).

Author: jieyouxu

src/bootstrap/src/core/build_steps/test.rs

@@ -8,6 +8,8 @@ use std::ffi::{OsStr, OsString};
 use std::path::{Path, PathBuf};
 use std::{env, fs, iter};
 
+use build_helper::exit;
+
 use crate::core::build_steps::compile::{Std, run_cargo};
 use crate::core::build_steps::doc::DocumentationFormat;
 use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
@@ -714,17 +716,24 @@ impl Step for CompiletestTest {
 
     /// Runs `cargo test` for compiletest.
     fn run(self, builder: &Builder<'_>) {
+        if builder.top_stage == 0 && !builder.config.compiletest_force_stage0 {
+            eprintln!(
+                "`compiletest` unit tests cannot be run against stage 0 unless `build.compiletest-force-stage0` override is specified"
+            );
+            exit!(1);
+        }
+
         let host = self.host;
         let compiler = builder.compiler(builder.top_stage, host);
 
-        // We need `ToolStd` for the locally-built sysroot because
-        // compiletest uses unstable features of the `test` crate.
+        // We need `ToolStd` for the locally-built sysroot because compiletest uses unstable
+        // features of the `test` crate.
         builder.std(compiler, host);
         let mut cargo = tool::prepare_tool_cargo(
             builder,
             compiler,
-            // compiletest uses libtest internals; make it use the in-tree std to make sure it never breaks
-            // when std sources change.
+            // compiletest uses libtest internals; make it use the in-tree std to make sure it never
+            // breaks when std sources change.
             Mode::ToolStd,
             host,
             Kind::Test,
@@ -1612,12 +1621,11 @@ impl Step for Compiletest {
             return;
         }
 
-        if builder.top_stage == 0 && env::var("COMPILETEST_FORCE_STAGE0").is_err() {
+        if builder.top_stage == 0 && !builder.config.compiletest_force_stage0 {
             eprintln!("\
-ERROR: `--stage 0` runs compiletest on the stage0 (precompiled) compiler, not your local changes, and will almost always cause tests to fail
-HELP: to test the compiler, use `--stage 1` instead
-HELP: to test the standard library, use `--stage 0 library/std` instead
-NOTE: if you're sure you want to do this, please open an issue as to why. In the meantime, you can override this with `COMPILETEST_FORCE_STAGE0=1`."
+ERROR: `--stage 0` runs `compiletest` on the stage0 (precompiled) compiler, not your local changes, and will almost always cause tests to fail
+HELP: to test the staged compiler/library, use `--stage 1` instead
+NOTE: if you're sure you want to do this, please open an issue as to why. In the meantime, you can override this with `--set build.compiletest-force-stage0=true`."
             );
             crate::exit!(1);
         }

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

@@ -496,7 +496,7 @@ macro_rules! bootstrap_tool {
                     build_compiler: self.compiler,
                     target: self.target,
                     tool: $tool_name,
-                    mode: if is_unstable {
+                    mode: if is_unstable || !builder.config.compiletest_force_stage0 {
                         // use in-tree libraries for unstable features
                         Mode::ToolStd
                     } else {

src/bootstrap/src/core/builder/tests.rs

@@ -1531,16 +1531,6 @@ mod snapshot {
         insta::assert_snapshot!(
             ctx.config("check")
                 .path("compiletest")
-                .render_steps(), @"[check] rustc 0 <host> -> Compiletest 1 <host>");
-    }
-
-    #[test]
-    fn check_compiletest_stage1_libtest() {
-        let ctx = TestCtx::new();
-        insta::assert_snapshot!(
-            ctx.config("check")
-                .path("compiletest")
-                .args(&["--set", "build.compiletest-use-stage0-libtest=false"])
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
@@ -1549,6 +1539,26 @@ mod snapshot {
         ");
     }
 
+    #[test]
+    #[should_panic]
+    fn test_compiletest_stage0_no_force() {
+        let ctx = TestCtx::new();
+        ctx.config("test").path("compiletest").stage(0).run();
+    }
+
+    #[test]
+    fn test_compiletest_force_stage0() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("test")
+                .path("compiletest")
+                .stage(0)
+                .args(&[
+                    "--set", "build.compiletest-force-stage0=true"
+                ])
+                .render_steps(), @"[build] rustdoc 0 <host>");
+    }
+
     #[test]
     fn check_codegen() {
         let ctx = TestCtx::new();

src/bootstrap/src/core/config/config.rs

@@ -293,6 +293,10 @@ pub struct Config {
     /// `paths=["foo", "bar"]`.
     pub paths: Vec<PathBuf>,
 
+    /// Force `compiletest` to be built and tested with stage 0 (compiler, library). Note that
+    /// `compiletest`'s own unit tests are not guaranteed to pass against stage 0 (compiler,
+    /// library)!
+    pub compiletest_force_stage0: bool,
     /// Command for visual diff display, e.g. `diff-tool --color=always`.
     pub compiletest_diff_tool: Option<String>,
 
@@ -744,6 +748,7 @@ impl Config {
             android_ndk,
             optimized_compiler_builtins,
             jobs,
+            compiletest_force_stage0,
             compiletest_diff_tool,
             tidy_extra_checks,
             ccache,
@@ -1009,7 +1014,10 @@ impl Config {
 
         config.optimized_compiler_builtins =
             optimized_compiler_builtins.unwrap_or(config.channel != "dev");
+
+        config.compiletest_force_stage0 = compiletest_force_stage0.unwrap_or(false);
         config.compiletest_diff_tool = compiletest_diff_tool;
+
         config.tidy_extra_checks = tidy_extra_checks;
 
         let download_rustc = config.download_rustc_commit.is_some();

src/bootstrap/src/core/config/toml/build.rs

@@ -67,6 +67,7 @@ define_config! {
         android_ndk: Option<PathBuf> = "android-ndk",
         optimized_compiler_builtins: Option<bool> = "optimized-compiler-builtins",
         jobs: Option<u32> = "jobs",
+        compiletest_force_stage0: Option<bool> = "compiletest-force-stage0",
         compiletest_diff_tool: Option<String> = "compiletest-diff-tool",
         tidy_extra_checks: Option<String> = "tidy-extra-checks",
         ccache: Option<StringOrBool> = "ccache",