bootstrap: add an initial stdarch test step

Author: mnmn-f

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

@@ -3028,6 +3028,63 @@ fn prepare_cargo_test(
 /// FIXME(Zalathar): Try to split this into two separate steps: a user-visible
 /// step for testing standard library crates, and an internal step used for both
 /// library crates and compiler crates.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Stdarch {
+    build_compiler: Compiler,
+    target: TargetSelection,
+}
+
+impl Step for Stdarch {
+    type Output = ();
+    const IS_HOST: bool = true;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.path("library/stdarch").path("library/stdarch/crates/core_arch")
+    }
+
+    fn is_default_step(_builder: &Builder<'_>) -> bool {
+        false
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        let builder = run.builder;
+        let host = run.build_triple();
+        let build_compiler = builder.compiler(builder.top_stage, host);
+
+        builder.ensure(Stdarch { build_compiler, target: run.target });
+    }
+
+    fn run(self, builder: &Builder<'_>) {
+        let build_compiler = self.build_compiler;
+        let target = self.target;
+
+        builder.ensure(Std::new(build_compiler, build_compiler.host).force_recompile(true));
+
+        if !builder.config.is_host_target(target) {
+            builder.ensure(compile::Std::new(build_compiler, target).force_recompile(true));
+            builder.ensure(RemoteCopyLibs { build_compiler, target });
+        }
+
+        let mut cargo = builder::Cargo::new(
+            builder,
+            build_compiler,
+            Mode::Std,
+            SourceType::InTree,
+            target,
+            builder.kind,
+        );
+
+        cargo.arg("--manifest-path").arg(builder.src.join("library/stdarch/Cargo.toml"));
+
+        let crates = vec!["core_arch".to_owned()];
+        run_cargo_test(cargo, &[], &crates, "stdarch", target, builder);
+    }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::test("stdarch", self.target).built_by(self.build_compiler))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Crate {
     /// The compiler that will *build* libstd or rustc in test mode.

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

@@ -871,6 +871,7 @@ impl<'a> Builder<'a> {
                 test::CrateRustdoc,
                 test::CrateRustdocJsonTypes,
                 test::CrateBootstrap,
+                test::Stdarch,
                 test::RemoteTestClientTests,
                 test::Linkcheck,
                 test::TierCheck,

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

@@ -39,6 +39,17 @@ fn run_build(paths: &[PathBuf], config: Config) -> Cache {
     builder.cache
 }
 
+fn configure_stdarch_test(paths: &[&str]) -> Config {
+    let ctx = TestCtx::new();
+    ctx.config("test")
+        .args(paths)
+        .args(&["--ci", "true"])
+        .hosts(&[TEST_TRIPLE_1])
+        .targets(&[TEST_TRIPLE_1])
+        .no_override_download_ci_llvm()
+        .create_config()
+}
+
 fn check_cli<const N: usize>(paths: [&str; N]) {
     run_build(
         &paths.map(PathBuf::from),
@@ -140,6 +151,16 @@ fn validate_path_remap() {
         });
 }
 
+#[test]
+fn test_stdarch_workspace_metadata_is_loaded() {
+    let build = Build::new(configure_stdarch_test(&[]));
+
+    assert_eq!(
+        build.crate_paths.get(&PathBuf::from("library/stdarch/crates/core_arch")),
+        Some(&"core_arch".to_owned())
+    );
+}
+
 #[test]
 fn check_missing_paths_for_x_test_tests() {
     let build = Build::new(configure("test", &[TEST_TRIPLE_1], &[TEST_TRIPLE_1]));
@@ -320,6 +341,14 @@ fn test_test_compiler() {
     assert_eq!((compiler, cranelift, gcc), (true, false, false));
 }
 
+#[test]
+fn test_test_stdarch() {
+    let config = configure_stdarch_test(&["library/stdarch"]);
+    let cache = run_build(&config.paths.clone(), config);
+
+    assert!(cache.contains::<test::Stdarch>());
+}
+
 #[test]
 fn test_test_coverage() {
     struct Case {

src/bootstrap/src/core/metadata.rs

@@ -93,9 +93,11 @@ fn workspace_members(build: &Build) -> Vec<Package> {
         packages
     };
 
-    // Collects `metadata.packages` from the root and library workspaces.
+    // Collect `metadata.packages` from the workspaces that bootstrap may need
+    // to resolve from CLI paths.
     let mut packages = vec![];
     packages.extend(collect_metadata("Cargo.toml"));
     packages.extend(collect_metadata("library/Cargo.toml"));
+    packages.extend(collect_metadata("library/stdarch/Cargo.toml"));
     packages
 }