Introduce a system of "directive handlers" indexed by directive name

Author: Zalathar

src/tools/compiletest/src/directives.rs

@@ -14,6 +14,7 @@ use crate::directives::directive_names::{
     KNOWN_DIRECTIVE_NAMES, KNOWN_HTMLDOCCK_DIRECTIVE_NAMES, KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate) use crate::directives::file::FileDirectives;
+use crate::directives::handlers::DIRECTIVE_HANDLERS_MAP;
 use crate::directives::line::{DirectiveLine, line_directive};
 use crate::directives::needs::CachedNeedsConditions;
 use crate::edition::{Edition, parse_edition};
@@ -26,6 +27,7 @@ mod auxiliary;
 mod cfg;
 mod directive_names;
 mod file;
+mod handlers;
 mod line;
 mod needs;
 #[cfg(test)]
@@ -369,22 +371,15 @@ impl TestProps {
                         return;
                     }
 
+                    if let Some(handler) = DIRECTIVE_HANDLERS_MAP.get(ln.name) {
+                        handler.handle(config, ln, self);
+                        // This directive has been handled, so move on to the next one.
+                        return;
+                    }
+
                     use directives::*;
                     let props = &mut *self;
 
-                    config.push_name_value_directive(
-                        ln,
-                        ERROR_PATTERN,
-                        &mut props.error_patterns,
-                        |r| r,
-                    );
-                    config.push_name_value_directive(
-                        ln,
-                        REGEX_ERROR_PATTERN,
-                        &mut props.regex_error_patterns,
-                        |r| r,
-                    );
-
                     config.push_name_value_directive(ln, DOC_FLAGS, &mut props.doc_flags, |r| r);
 
                     fn split_flags(flags: &str) -> Vec<String> {

src/tools/compiletest/src/directives/handlers.rs

@@ -0,0 +1,78 @@
+use std::collections::HashMap;
+use std::sync::{Arc, LazyLock};
+
+use crate::common::Config;
+use crate::directives::{DirectiveLine, TestProps};
+
+pub(crate) static DIRECTIVE_HANDLERS_MAP: LazyLock<HashMap<&str, Handler>> =
+    LazyLock::new(make_directive_handlers_map);
+
+#[derive(Clone)]
+pub(crate) struct Handler {
+    handler_fn: Arc<dyn Fn(HandlerArgs<'_>) + Send + Sync>,
+}
+
+impl Handler {
+    pub(crate) fn handle(&self, config: &Config, line: &DirectiveLine<'_>, props: &mut TestProps) {
+        (self.handler_fn)(HandlerArgs { config, line, props })
+    }
+}
+
+struct HandlerArgs<'a> {
+    config: &'a Config,
+    line: &'a DirectiveLine<'a>,
+    props: &'a mut TestProps,
+}
+
+/// Intermediate data structure, used for defining a list of handlers.
+struct NamedHandler {
+    names: Vec<&'static str>,
+    handler: Handler,
+}
+
+/// Helper function to create a simple handler, so that changes can be made
+/// to the handler struct without disturbing existing handler declarations.
+fn handler(
+    name: &'static str,
+    handler_fn: impl Fn(&Config, &DirectiveLine<'_>, &mut TestProps) + Send + Sync + 'static,
+) -> NamedHandler {
+    multi_handler(&[name], handler_fn)
+}
+
+/// Associates the same handler function with multiple directive names.
+fn multi_handler(
+    names: &[&'static str],
+    handler_fn: impl Fn(&Config, &DirectiveLine<'_>, &mut TestProps) + Send + Sync + 'static,
+) -> NamedHandler {
+    NamedHandler {
+        names: names.to_owned(),
+        handler: Handler {
+            handler_fn: Arc::new(move |args| handler_fn(args.config, args.line, args.props)),
+        },
+    }
+}
+
+fn make_directive_handlers_map() -> HashMap<&'static str, Handler> {
+    use crate::directives::directives::*;
+
+    let handlers: Vec<NamedHandler> = vec![
+        handler(ERROR_PATTERN, |config, ln, props| {
+            config.push_name_value_directive(ln, ERROR_PATTERN, &mut props.error_patterns, |r| r);
+        }),
+        handler(REGEX_ERROR_PATTERN, |config, ln, props| {
+            config.push_name_value_directive(
+                ln,
+                REGEX_ERROR_PATTERN,
+                &mut props.regex_error_patterns,
+                |r| r,
+            );
+        }),
+    ];
+
+    handlers
+        .into_iter()
+        .flat_map(|NamedHandler { names, handler }| {
+            names.into_iter().map(move |name| (name, Handler::clone(&handler)))
+        })
+        .collect()
+}

src/tools/compiletest/src/directives/tests.rs

@@ -1,14 +1,33 @@
+use std::collections::{BTreeSet, HashSet};
+
 use camino::Utf8Path;
 use semver::Version;
 
 use crate::common::{Config, Debugger, TestMode};
 use crate::directives::{
-    AuxProps, DirectivesCache, EarlyProps, Edition, EditionRange, FileDirectives,
-    extract_llvm_version, extract_version_range, iter_directives, line_directive, parse_edition,
-    parse_normalize_rule,
+    AuxProps, DIRECTIVE_HANDLERS_MAP, DirectivesCache, EarlyProps, Edition, EditionRange,
+    FileDirectives, KNOWN_DIRECTIVE_NAMES, extract_llvm_version, extract_version_range,
+    iter_directives, line_directive, parse_edition, parse_normalize_rule,
 };
 use crate::executor::{CollectedTestDesc, ShouldFail};
 
+/// All directive handlers should have a name that is also in `KNOWN_DIRECTIVE_NAMES`.
+#[test]
+fn handler_names() {
+    let known_directive_names = KNOWN_DIRECTIVE_NAMES.iter().copied().collect::<HashSet<_>>();
+
+    let unknown_names = DIRECTIVE_HANDLERS_MAP
+        .keys()
+        .copied()
+        .filter(|name| !known_directive_names.contains(name))
+        .collect::<BTreeSet<_>>();
+
+    assert!(
+        unknown_names.is_empty(),
+        "Directive handler names not in `directive_names.rs`: {unknown_names:#?}"
+    );
+}
+
 fn make_test_description(
     config: &Config,
     name: String,