Only run tests/assembly-* and tests/codegen-* tests if they match the current codegen backend

Author: GuillaumeGomez

src/tools/compiletest/src/common.rs

@@ -55,6 +55,7 @@ impl TestMode {
 
 // Note that coverage tests use the same test files for multiple test modes.
 string_enum! {
+    no_from_str,
     #[derive(Clone, Copy, PartialEq, Debug)]
     pub enum TestSuite {
         Assembly => "assembly",
@@ -79,6 +80,42 @@ string_enum! {
     }
 }
 
+impl ::std::str::FromStr for TestSuite {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "codegen-units" => Self::CodegenUnits,
+            "coverage" => Self::Coverage,
+            "coverage-run-rustdoc" => Self::CoverageRunRustdoc,
+            "crashes" => Self::Crashes,
+            "debuginfo" => Self::Debuginfo,
+            "incremental" => Self::Incremental,
+            "mir-opt" => Self::MirOpt,
+            "pretty" => Self::Pretty,
+            "run-make" => Self::RunMake,
+            "rustdoc" => Self::Rustdoc,
+            "rustdoc-gui" => Self::RustdocGui,
+            "rustdoc-js" => Self::RustdocJs,
+            "rustdoc-js-std" => Self::RustdocJsStd,
+            "rustdoc-json" => Self::RustdocJson,
+            "rustdoc-ui" => Self::RustdocUi,
+            "ui" => Self::Ui,
+            "ui-fulldeps" => Self::UiFullDeps,
+            s => {
+                if let Some((test_suite @ ("assembly" | "codegen"), codegen_backend)) =
+                    s.split_once('-')
+                    && CodegenBackend::try_from(codegen_backend).is_ok()
+                {
+                    if test_suite == "assembly" { Self::Assembly } else { Self::Codegen }
+                } else {
+                    return Err(format!("unknown `TestSuite` variant: `{s}`"));
+                }
+            }
+        })
+    }
+}
+
 string_enum! {
     #[derive(Clone, Copy, PartialEq, Debug, Hash)]
     pub enum PassMode {

src/tools/compiletest/src/lib.rs

@@ -31,7 +31,7 @@ use std::time::SystemTime;
 use std::{env, fs, vec};
 
 use build_helper::git::{get_git_modified_files, get_git_untracked_files};
-use camino::{Utf8Path, Utf8PathBuf};
+use camino::{Utf8Component, Utf8Path, Utf8PathBuf};
 use getopts::Options;
 use rayon::iter::{ParallelBridge, ParallelIterator};
 use tracing::debug;
@@ -799,6 +799,23 @@ fn collect_tests_from_dir(
         return Ok(TestCollector::new());
     }
 
+    let mut components = dir.components().rev();
+    if let Some(Utf8Component::Normal(last)) = components.next()
+        && let Some(("assembly" | "codegen", backend)) = last.split_once('-')
+        && let Some(Utf8Component::Normal(parent)) = components.next()
+        && parent == "tests"
+        && let Ok(backend) = CodegenBackend::try_from(backend)
+        && backend != cx.config.codegen_backend
+    {
+        // We ignore asm tests which don't match the current codegen backend.
+        println!(
+            "Ignoring tests in `{dir}` because they don't match the configured codegen \
+             backend (`{}`)",
+            cx.config.codegen_backend.as_str(),
+        );
+        return Ok(TestCollector::new());
+    }
+
     // For run-make tests, a "test file" is actually a directory that contains an `rmake.rs`.
     if cx.config.mode == TestMode::RunMake {
         let mut collector = TestCollector::new();

src/tools/compiletest/src/util.rs

@@ -106,7 +106,7 @@ macro_rules! static_regex {
 pub(crate) use static_regex;
 
 macro_rules! string_enum {
-    ($(#[$meta:meta])* $vis:vis enum $name:ident { $($variant:ident => $repr:expr,)* }) => {
+    (no_from_str, $(#[$meta:meta])* $vis:vis enum $name:ident { $($variant:ident => $repr:expr,)* }) => {
         $(#[$meta])*
         $vis enum $name {
             $($variant,)*
@@ -128,6 +128,9 @@ macro_rules! string_enum {
                 ::std::fmt::Display::fmt(self.to_str(), f)
             }
         }
+    };
+    ($(#[$meta:meta])* $vis:vis enum $name:ident { $($variant:ident => $repr:expr,)* }) => {
+        $crate::util::string_enum!(no_from_str, $(#[$meta])* $vis enum $name { $($variant => $repr,)* });
 
         impl ::std::str::FromStr for $name {
             type Err = String;