refactor(infra): improve conformance runner

Author: re-taro

tasks/coverage/src/file_discovery.rs

@@ -0,0 +1,126 @@
+//! File discovery layer for conformance test suites
+//!
+//! This module provides centralized file discovery to avoid redundant directory traversals.
+//! Instead of each Suite walking the directory tree independently, file discovery is performed
+//! once per test root directory and the results are shared across multiple tool runs.
+
+use std::{
+    fs,
+    io::Read,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
+
+use encoding_rs::UTF_16LE;
+use encoding_rs_io::DecodeReaderBytesBuilder;
+use walkdir::WalkDir;
+
+use crate::workspace_root;
+
+/// Discovered test files from a single test root directory
+#[derive(Debug, Clone)]
+pub struct DiscoveredFiles {
+    /// Root directory that was scanned
+    #[expect(dead_code)]
+    pub test_root: PathBuf,
+    /// List of discovered file paths (relative to workspace root)
+    pub files: Vec<DiscoveredFile>,
+}
+
+/// A single discovered test file
+#[derive(Debug, Clone)]
+pub struct DiscoveredFile {
+    /// Path relative to workspace root
+    pub path: PathBuf,
+    /// Source code content
+    pub code: String,
+}
+
+/// File discovery configuration
+pub struct FileDiscoveryConfig<'a> {
+    /// Test root directory relative to workspace
+    pub test_root: &'a Path,
+    /// Optional filter string to match against file paths
+    pub filter: Option<&'a str>,
+    /// Function to determine if a path should be skipped
+    pub skip_test_path: Box<dyn Fn(&Path) -> bool + 'a>,
+    /// Whether to skip directory crawl entirely
+    pub skip_test_crawl: bool,
+    /// Name of the test suite (for submodule initialization messages)
+    pub suite_name: &'a str,
+}
+
+impl DiscoveredFiles {
+    /// Discover files from a test root directory
+    pub fn discover(config: &FileDiscoveryConfig<'_>) -> Self {
+        let test_path = workspace_root();
+        let test_root = config.test_root.to_path_buf();
+
+        let paths = if config.skip_test_crawl {
+            vec![]
+        } else {
+            let cases_path = test_path.join(&test_root);
+
+            let get_paths = || {
+                WalkDir::new(&cases_path)
+                    .into_iter()
+                    .filter_map(Result::ok)
+                    .filter(|e| !e.file_type().is_dir())
+                    .filter(|e| e.file_name() != ".DS_Store")
+                    .map(|e| e.path().to_owned())
+                    .filter(|path| !(config.skip_test_path)(path))
+                    .filter(|path| {
+                        config.filter.is_none_or(|query| path.to_string_lossy().contains(query))
+                    })
+                    .collect::<Vec<_>>()
+            };
+
+            let mut paths = get_paths();
+
+            // Initialize git submodule if it is empty and no filter is provided
+            if paths.is_empty() && config.filter.is_none() {
+                println!("-------------------------------------------------------");
+                println!("git submodule is empty for {}", config.suite_name);
+                println!("Running `just submodules` to clone the submodules");
+                println!("This may take a while.");
+                println!("-------------------------------------------------------");
+                Command::new("just")
+                    .args(["submodules"])
+                    .stdout(Stdio::inherit())
+                    .stderr(Stdio::inherit())
+                    .output()
+                    .expect("failed to execute `just submodules`");
+                paths = get_paths();
+            }
+            paths
+        };
+
+        // Read all files in parallel
+        let files = paths
+            .into_iter()
+            .map(|path| {
+                let mut code = fs::read_to_string(&path).unwrap_or_else(|_| {
+                    // TypeScript tests may contain utf_16 encoding files
+                    let file = fs::File::open(&path).unwrap();
+                    let mut content = String::new();
+                    DecodeReaderBytesBuilder::new()
+                        .encoding(Some(UTF_16LE))
+                        .build(file)
+                        .read_to_string(&mut content)
+                        .unwrap();
+                    content
+                });
+
+                let path = path.strip_prefix(&test_path).unwrap().to_owned();
+                // Remove the Byte Order Mark in some of the TypeScript files
+                if code.starts_with('\u{feff}') {
+                    code.remove(0);
+                }
+
+                DiscoveredFile { path, code }
+            })
+            .collect();
+
+        Self { test_root, files }
+    }
+}