Apply a clearer naming convention to many of the test steps

Author: Zalathar

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

@@ -627,7 +627,7 @@ impl Step for StdLink {
         let target_compiler = self.target_compiler;
         let target = self.target;
 
-        // NOTE: intentionally does *not* check `target == builder.build` to avoid having to add the same check in `test::Crate`.
+        // NOTE: intentionally does *not* check `target == builder.build` to avoid having to add the same check in `test::SelftestLibraryOrOtherCrate`.
         let (libdir, hostdir) = if self.force_recompile && builder.download_rustc() {
             // NOTE: copies part of `sysroot_libdir` to avoid having to add a new `force_recompile` argument there too
             let lib = builder.sysroot_libdir_relative(self.compiler);

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

@@ -705,8 +705,8 @@ impl<'a> ShouldRun<'a> {
     /// removing the matches from `paths`.
     ///
     /// NOTE: this returns multiple PathSets to allow for the possibility of multiple units of work
-    /// within the same step. For example, `test::Crate` allows testing multiple crates in the same
-    /// cargo invocation, which are put into separate sets because they aren't aliases.
+    /// within the same step. For example, `test::SelftestLibraryOrOtherCrate` allows testing multiple
+    /// crates in the same cargo invocation, which are put into separate sets because they aren't aliases.
     ///
     /// The reason we return PathSet instead of PathBuf is to allow for aliases that mean the same thing
     /// (for now, just `all_krates` and `paths`, but we may want to add an `aliases` function in the future?)
@@ -939,70 +939,72 @@ impl<'a> Builder<'a> {
             ),
             Kind::Test => describe!(
                 crate::core::build_steps::toolstate::ToolStateCheck,
-                test::Tidy,
-                test::Ui,
-                test::Crashes,
-                test::Coverage,
-                test::CoverageMap,
-                test::CoverageRun,
-                test::MirOpt,
-                test::Codegen,
-                test::CodegenUnits,
-                test::Assembly,
-                test::Incremental,
-                test::Debuginfo,
-                test::UiFullDeps,
-                test::Rustdoc,
-                test::CoverageRunRustdoc,
-                test::Pretty,
-                test::CodegenCranelift,
-                test::CodegenGCC,
-                test::Crate,
-                test::CrateLibrustc,
-                test::CrateRustdoc,
-                test::CrateRustdocJsonTypes,
-                test::CrateBootstrap,
+                test::InvokeTidy,
+                test::SuiteUi,
+                test::SuiteCrashes,
+                test::SuiteCoverage,
+                test::SuiteCoverageMap,
+                test::SuiteCoverageRun,
+                test::SuiteMirOpt,
+                test::SuiteCodegen,
+                test::SuiteCodegenUnits,
+                test::SuiteAssembly,
+                test::SuiteIncremental,
+                test::SuiteDebuginfo,
+                test::SuiteUiFullDeps,
+                test::SuiteRustdoc,
+                test::SuiteCoverageRunRustdoc,
+                test::SuitePretty,
+                test::SelftestCodegenCranelift,
+                test::SelftestCodegenGCC,
+                test::SelftestLibraryOrOtherCrates,
+                test::SelftestCompilerCrates,
+                test::SelftestRustdoc,
+                test::SelftestRustdocJsonTypes,
+                test::SelftestMiscBootstrapTools,
                 test::Linkcheck,
                 test::TierCheck,
                 test::Cargotest,
-                test::Cargo,
-                test::RustAnalyzer,
+                test::SelftestCargo,
+                test::SelftestRustAnalyzer,
                 test::ErrorIndex,
                 test::Distcheck,
-                test::Nomicon,
-                test::Reference,
-                test::RustdocBook,
-                test::RustByExample,
-                test::TheBook,
-                test::UnstableBook,
-                test::RustcBook,
+                test::BooktestNomicon,
+                test::BooktestReference,
+                test::BooktestRustdocBook,
+                test::BooktestRustByExample,
+                test::BooktestTheBook,
+                test::BooktestUnstableBook,
+                test::BooktestRustcBook,
                 test::LintDocs,
-                test::EmbeddedBook,
-                test::EditionGuide,
-                test::Rustfmt,
-                test::Miri,
+                test::BooktestEmbeddedBook,
+                test::BooktestEditionGuide,
+                test::SelftestRustfmt,
+                test::SelftestMiri,
                 test::CargoMiri,
-                test::Clippy,
-                test::CompiletestTest,
-                test::CrateRunMakeSupport,
-                test::CrateBuildHelper,
-                test::RustdocJSStd,
-                test::RustdocJSNotStd,
-                test::RustdocGUI,
+                test::SelftestClippy,
+                test::SelftestCompiletest,
+                test::SelftestRunMakeSupport,
+                test::SelftestBuildHelper,
+                test::SuiteRustdocJSStd,
+                test::SuiteRustdocJSNotStd,
+                test::SuiteRustdocGUI,
                 test::RustdocTheme,
-                test::RustdocUi,
-                test::RustdocJson,
+                test::SuiteRustdocUi,
+                test::SuiteRustdocJson,
                 test::HtmlCheck,
                 test::RustInstaller,
                 test::TestFloatParse,
                 test::CollectLicenseMetadata,
                 // Run bootstrap close to the end as it's unlikely to fail
-                test::Bootstrap,
+                test::SelftestBootstrap,
                 // Run run-make last, since these won't pass without make on Windows
-                test::RunMake,
+                test::SuiteRunMake,
             ),
-            Kind::Miri => describe!(test::Crate),
-            Kind::Bench => describe!(test::Crate, test::CrateLibrustc),
+            Kind::Miri => describe!(test::SelftestLibraryOrOtherCrates),
+            Kind::Bench => {
+                describe!(test::SelftestLibraryOrOtherCrates, test::SelftestCompilerCrates)
+            }
             Kind::Doc => describe!(
                 doc::UnstableBook,
                 doc::UnstableBookGen,

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

@@ -185,10 +185,10 @@ fn test_exclude() {
     let cache = run_build(&[], config);
 
     // Ensure we have really excluded tidy
-    assert!(!cache.contains::<test::Tidy>());
+    assert!(!cache.contains::<test::InvokeTidy>());
 
     // Ensure other tests are not affected.
-    assert!(cache.contains::<test::RustdocUi>());
+    assert!(cache.contains::<test::SuiteRustdocUi>());
 }
 
 #[test]
@@ -197,10 +197,10 @@ fn test_exclude_kind() {
 
     let mut config = configure("test", &[TEST_TRIPLE_1], &[TEST_TRIPLE_1]);
     // Ensure our test is valid, and `test::Rustc` would be run without the exclude.
-    assert!(run_build(&[], config.clone()).contains::<test::CrateLibrustc>());
+    assert!(run_build(&[], config.clone()).contains::<test::SelftestCompilerCrates>());
     // Ensure tests for rustc are not skipped.
     config.skip = vec![path.clone()];
-    assert!(run_build(&[], config.clone()).contains::<test::CrateLibrustc>());
+    assert!(run_build(&[], config.clone()).contains::<test::SelftestCompilerCrates>());
     // Ensure builds for rustc are not skipped.
     assert!(run_build(&[], config).contains::<compile::Rustc>());
 }
@@ -669,18 +669,21 @@ mod dist {
 
         let host = TargetSelection::from_user(TEST_TRIPLE_1);
 
-        builder.run_step_descriptions(&[StepDescription::from::<test::Crate>(Kind::Test)], &[
-            "library/std".into(),
-        ]);
+        builder.run_step_descriptions(
+            &[StepDescription::from::<test::SelftestLibraryOrOtherCrates>(Kind::Test)],
+            &["library/std".into()],
+        );
 
         // Ensure we don't build any compiler artifacts.
         assert!(!builder.cache.contains::<compile::Rustc>());
-        assert_eq!(first(builder.cache.all::<test::Crate>()), &[test::Crate {
-            compiler: Compiler { host, stage: 0 },
-            target: host,
-            mode: crate::Mode::Std,
-            crates: vec!["std".to_owned()],
-        },]);
+        assert_eq!(first(builder.cache.all::<test::SelftestLibraryOrOtherCrates>()), &[
+            test::SelftestLibraryOrOtherCrates {
+                compiler: Compiler { host, stage: 0 },
+                target: host,
+                mode: crate::Mode::Std,
+                crates: vec!["std".to_owned()],
+            },
+        ]);
     }
 
     #[test]
@@ -822,9 +825,9 @@ fn test_test_compiler() {
     let config = configure_with_args(cmd, &[TEST_TRIPLE_1], &[TEST_TRIPLE_1]);
     let cache = run_build(&config.paths.clone(), config);
 
-    let compiler = cache.contains::<test::CrateLibrustc>();
-    let cranelift = cache.contains::<test::CodegenCranelift>();
-    let gcc = cache.contains::<test::CodegenGCC>();
+    let compiler = cache.contains::<test::SelftestCompilerCrates>();
+    let cranelift = cache.contains::<test::SelftestCodegenCranelift>();
+    let gcc = cache.contains::<test::SelftestCodegenGCC>();
 
     assert_eq!((compiler, cranelift, gcc), (true, false, false));
 }