Change struct Need to use new test directive needs-atomic

Author: kei519

src/tools/compiletest/src/header/needs.rs

@@ -8,170 +8,190 @@ pub(super) fn handle_needs(
 ) -> IgnoreDecision {
     // Note thet we intentionally still put the needs- prefix here to make the file show up when
     // grepping for a directive name, even though we could technically strip that.
-    let needs = &[
+    let needs = &mut [
         Need {
             name: "needs-asm-support",
-            condition: config.has_asm_support(),
+            condition: &mut |_| config.has_asm_support().then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without inline assembly support",
         },
         Need {
             name: "needs-sanitizer-support",
-            condition: cache.sanitizer_support,
+            condition: &mut |_| cache.sanitizer_support.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without sanitizers support",
         },
         Need {
             name: "needs-sanitizer-address",
-            condition: cache.sanitizer_address,
+            condition: &mut |_| cache.sanitizer_address.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without address sanitizer",
         },
         Need {
             name: "needs-sanitizer-cfi",
-            condition: cache.sanitizer_cfi,
+            condition: &mut |_| cache.sanitizer_cfi.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without CFI sanitizer",
         },
         Need {
             name: "needs-sanitizer-dataflow",
-            condition: cache.sanitizer_dataflow,
+            condition: &mut |_| cache.sanitizer_dataflow.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without dataflow sanitizer",
         },
         Need {
             name: "needs-sanitizer-kcfi",
-            condition: cache.sanitizer_kcfi,
+            condition: &mut |_| cache.sanitizer_kcfi.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without kernel CFI sanitizer",
         },
         Need {
             name: "needs-sanitizer-kasan",
-            condition: cache.sanitizer_kasan,
+            condition: &mut |_| cache.sanitizer_kasan.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without kernel address sanitizer",
         },
         Need {
             name: "needs-sanitizer-leak",
-            condition: cache.sanitizer_leak,
+            condition: &mut |_| cache.sanitizer_leak.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without leak sanitizer",
         },
         Need {
             name: "needs-sanitizer-memory",
-            condition: cache.sanitizer_memory,
+            condition: &mut |_| cache.sanitizer_memory.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without memory sanitizer",
         },
         Need {
             name: "needs-sanitizer-thread",
-            condition: cache.sanitizer_thread,
+            condition: &mut |_| cache.sanitizer_thread.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without thread sanitizer",
         },
         Need {
             name: "needs-sanitizer-hwaddress",
-            condition: cache.sanitizer_hwaddress,
+            condition: &mut |_| cache.sanitizer_hwaddress.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without hardware-assisted address sanitizer",
         },
         Need {
             name: "needs-sanitizer-memtag",
-            condition: cache.sanitizer_memtag,
+            condition: &mut |_| cache.sanitizer_memtag.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without memory tagging sanitizer",
         },
         Need {
             name: "needs-sanitizer-shadow-call-stack",
-            condition: cache.sanitizer_shadow_call_stack,
+            condition: &mut |_| {
+                cache.sanitizer_shadow_call_stack.then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored on targets without shadow call stacks",
         },
         Need {
             name: "needs-sanitizer-safestack",
-            condition: cache.sanitizer_safestack,
+            condition: &mut |_| cache.sanitizer_safestack.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without SafeStack support",
         },
         Need {
             name: "needs-enzyme",
-            condition: config.has_enzyme,
+            condition: &mut |_| config.has_enzyme.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored when LLVM Enzyme is disabled",
         },
         Need {
             name: "needs-run-enabled",
-            condition: config.run_enabled(),
+            condition: &mut |_| config.run_enabled().then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored when running the resulting test binaries is disabled",
         },
         Need {
             name: "needs-threads",
-            condition: config.has_threads(),
+            condition: &mut |_| config.has_threads().then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without threading support",
         },
         Need {
             name: "needs-unwind",
-            condition: config.can_unwind(),
+            condition: &mut |_| config.can_unwind().then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without unwinding support",
         },
         Need {
             name: "needs-profiler-runtime",
-            condition: config.profiler_runtime,
+            condition: &mut |_| config.profiler_runtime.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored when the profiler runtime is not available",
         },
         Need {
             name: "needs-force-clang-based-tests",
-            condition: config.run_clang_based_tests_with.is_some(),
+            condition: &mut |_| {
+                config.run_clang_based_tests_with.is_some().then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored when RUSTBUILD_FORCE_CLANG_BASED_TESTS is not set",
         },
         Need {
             name: "needs-xray",
-            condition: cache.xray,
+            condition: &mut |_| cache.xray.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without xray tracing",
         },
         Need {
             name: "needs-rust-lld",
-            condition: cache.rust_lld,
+            condition: &mut |_| cache.rust_lld.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored on targets without Rust's LLD",
         },
         Need {
             name: "needs-dlltool",
-            condition: cache.dlltool,
+            condition: &mut |_| cache.dlltool.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored when dlltool for the current architecture is not present",
         },
         Need {
             name: "needs-git-hash",
-            condition: config.git_hash,
+            condition: &mut |_| config.git_hash.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored when git hashes have been omitted for building",
         },
         Need {
             name: "needs-dynamic-linking",
-            condition: config.target_cfg().dynamic_linking,
+            condition: &mut |_| {
+                config.target_cfg().dynamic_linking.then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored on targets without dynamic linking",
         },
         Need {
             name: "needs-relocation-model-pic",
-            condition: config.target_cfg().relocation_model == "pic",
+            condition: &mut |_| {
+                (config.target_cfg().relocation_model == "PIC").then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored on targets without PIC relocation model",
         },
         Need {
             name: "needs-deterministic-layouts",
-            condition: !config.rust_randomized_layout,
+            condition: &mut |_| {
+                (!config.rust_randomized_layout).then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored when randomizing layouts",
         },
         Need {
             name: "needs-wasmtime",
-            condition: config.runner.as_ref().is_some_and(|r| r.contains("wasmtime")),
+            condition: &mut |_| {
+                config
+                    .runner
+                    .as_ref()
+                    .is_some_and(|r| r.contains("wasmtime"))
+                    .then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored when wasmtime runner is not available",
         },
         Need {
             name: "needs-symlink",
-            condition: cache.symlinks,
+            condition: &mut |_| cache.symlinks.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored if symlinks are unavailable",
         },
         Need {
             name: "needs-llvm-zstd",
-            condition: cache.llvm_zstd,
+            condition: &mut |_| cache.llvm_zstd.then_some(IgnoreDecision::Continue),
             ignore_reason: "ignored if LLVM wasn't build with zstd for ELF section compression",
         },
         Need {
             name: "needs-rustc-debug-assertions",
-            condition: config.with_rustc_debug_assertions,
+            condition: &mut |_| {
+                config.with_rustc_debug_assertions.then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored if rustc wasn't built with debug assertions",
         },
         Need {
             name: "needs-std-debug-assertions",
-            condition: config.with_std_debug_assertions,
+            condition: &mut |_| {
+                config.with_std_debug_assertions.then_some(IgnoreDecision::Continue)
+            },
             ignore_reason: "ignored if std wasn't built with debug assertions",
         },
     ];
 
-    let (name, comment) = match ln.split_once([':', ' ']) {
+    let (name, mut comment) = match ln.split_once([':', ' ']) {
         Some((name, comment)) => (name, Some(comment)),
         None => (ln, None),
     };
@@ -185,34 +205,31 @@ pub(super) fn handle_needs(
         return IgnoreDecision::Continue;
     }
 
-    let mut found_valid = false;
-    for need in needs {
-        if need.name == name {
-            if need.condition {
-                found_valid = true;
-                break;
+    needs
+        .iter_mut()
+        .find_map(|need| {
+            if need.name == name {
+                (need.condition)(&mut comment).or_else(|| {
+                    Some(IgnoreDecision::Ignore {
+                        reason: if let Some(comment) = comment {
+                            format!("{} ({})", need.ignore_reason, comment.trim())
+                        } else {
+                            need.ignore_reason.into()
+                        },
+                    })
+                })
             } else {
-                return IgnoreDecision::Ignore {
-                    reason: if let Some(comment) = comment {
-                        format!("{} ({})", need.ignore_reason, comment.trim())
-                    } else {
-                        need.ignore_reason.into()
-                    },
-                };
+                None
             }
-        }
-    }
-
-    if found_valid {
-        IgnoreDecision::Continue
-    } else {
-        IgnoreDecision::Error { message: format!("invalid needs directive: {name}") }
-    }
+        })
+        .unwrap_or_else(|| IgnoreDecision::Error {
+            message: format!("invalid needs directive: {name}"),
+        })
 }
 
-struct Need {
+struct Need<'a> {
     name: &'static str,
-    condition: bool,
+    condition: &'a mut dyn FnMut(&mut Option<&str>) -> Option<IgnoreDecision>,
     ignore_reason: &'static str,
 }