wip: tag resolver optimizations

Author: omarabid

src/benches/tag_resolver_bench.rs

@@ -98,6 +98,45 @@ fn bench_find_files_for_tag_large_dataset(c: &mut Criterion) {
     });
 }
 
+fn bench_find_files_for_tag_mega_large_dataset(c: &mut Criterion) {
+    let target_tag = create_test_tag("core");
+    let mut files = Vec::new();
+
+    // Create 25,000 files with mixed tags
+    for i in 0..25000 {
+        let tags = if i % 100 == 0 {
+            // 1% of files with target tag
+            vec![target_tag.clone()]
+        } else if i % 100 == 1 {
+            // 1% of files with target + another tag
+            vec![target_tag.clone(), create_test_tag("shared")]
+        } else if i % 100 == 2 {
+            // 1% of files with target + multiple tags
+            vec![
+                target_tag.clone(),
+                create_test_tag(&format!("module-{}", i % 20)),
+                create_test_tag(&format!("type-{}", i % 10)),
+            ]
+        } else {
+            // 97% of files with other tags
+            vec![create_test_tag(&format!("module-{}", i % 50))]
+        };
+        files.push(create_test_file_entry(
+            &format!(
+                "src/module_{}/submodule_{}/file_{}.rs",
+                i / 1000,
+                (i / 100) % 10,
+                i
+            ),
+            tags,
+        ));
+    }
+
+    c.bench_function("find_files_for_tag_mega_large", |b| {
+        b.iter(|| find_files_for_tag(black_box(&files), black_box(&target_tag)))
+    });
+}
+
 fn bench_find_files_for_tag_no_matches(c: &mut Criterion) {
     let target_tag = create_test_tag("nonexistent");
     let mut files = Vec::new();
@@ -402,6 +441,7 @@ criterion_group!(
     bench_find_files_for_tag_small_dataset,
     bench_find_files_for_tag_medium_dataset,
     bench_find_files_for_tag_large_dataset,
+    bench_find_files_for_tag_mega_large_dataset,
     bench_find_files_for_tag_no_matches,
     bench_find_files_for_tag_multiple_tags_per_file,
     bench_find_tags_for_file_simple_pattern,

src/core/tag_resolver.rs

@@ -1,15 +1,24 @@
 use crate::utils::error::{Error, Result};
 use ignore::overrides::{Override, OverrideBuilder};
+
 use std::path::{Path, PathBuf};
 
-use super::types::{CodeownersEntry, FileEntry, Tag};
+use super::{
+    smart_iter::SmartIter,
+    types::{CodeownersEntry, FileEntry, Tag},
+};
 
 /// Find all files tagged with a specific tag
 pub fn find_files_for_tag(files: &[FileEntry], tag: &Tag) -> Vec<PathBuf> {
     files
         .iter()
-        .filter(|file_entry| file_entry.tags.contains(tag))
-        .map(|file_entry| file_entry.path.clone())
+        .filter_map(|file_entry| {
+            if file_entry.tags.contains(tag) {
+                Some(file_entry.path.clone())
+            } else {
+                None
+            }
+        })
         .collect()
 }
 
@@ -22,64 +31,63 @@ pub fn find_tags_for_file(file_path: &Path, entries: &[CodeownersEntry]) -> Resu
         )
     })?;
 
-    let mut candidates = Vec::new();
-
-    for entry in entries {
-        let codeowners_dir = match entry.source_file.parent() {
-            Some(dir) => dir,
-            None => {
-                eprintln!(
-                    "CODEOWNERS entry has no parent directory: {}",
-                    entry.source_file.display()
-                );
-                continue;
+    let mut candidates = entries
+        .smart_iter(3)
+        .filter_map(|entry| {
+            let codeowners_dir = match entry.source_file.parent() {
+                Some(dir) => dir,
+                None => {
+                    eprintln!(
+                        "CODEOWNERS entry has no parent directory: {}",
+                        entry.source_file.display()
+                    );
+                    return None;
+                }
+            };
+
+            // Check if the CODEOWNERS directory is an ancestor of the target directory
+            if !target_dir.starts_with(codeowners_dir) {
+                return None;
             }
-        };
 
-        // Check if the CODEOWNERS directory is an ancestor of the target directory
-        if !target_dir.starts_with(codeowners_dir) {
-            continue;
-        }
+            // Calculate the depth as the number of components in the relative path from codeowners_dir to target_dir
+            let rel_path = match target_dir.strip_prefix(codeowners_dir) {
+                Ok(p) => p,
+                Err(_) => return None, // Should not happen due to starts_with check
+            };
+            let depth = rel_path.components().count();
 
-        // Calculate the depth as the number of components in the relative path from codeowners_dir to target_dir
-        let rel_path = match target_dir.strip_prefix(codeowners_dir) {
-            Ok(p) => p,
-            Err(_) => continue, // Should not happen due to starts_with check
-        };
-        let depth = rel_path.components().count();
-
-        // Check if the pattern matches the target file
-        let matches = {
-            let mut builder = OverrideBuilder::new(codeowners_dir);
-            if let Err(e) = builder.add(&entry.pattern) {
-                eprintln!(
-                    "Invalid pattern '{}' in {}: {}",
-                    entry.pattern,
-                    entry.source_file.display(),
-                    e
-                );
-                continue;
-            }
-            let over: Override = match builder.build() {
-                Ok(o) => o,
-                Err(e) => {
+            // Check if the pattern matches the target file
+            let matches = {
+                let mut builder = OverrideBuilder::new(codeowners_dir);
+                if let Err(e) = builder.add(&entry.pattern) {
                     eprintln!(
-                        "Failed to build override for pattern '{}': {}",
-                        entry.pattern, e
+                        "Invalid pattern '{}' in {}: {}",
+                        entry.pattern,
+                        entry.source_file.display(),
+                        e
                     );
-                    continue;
+                    return None;
                 }
+                let over: Override = match builder.build() {
+                    Ok(o) => o,
+                    Err(e) => {
+                        eprintln!(
+                            "Failed to build override for pattern '{}': {}",
+                            entry.pattern, e
+                        );
+                        return None;
+                    }
+                };
+                over.matched(file_path, false).is_whitelist()
             };
-            over.matched(file_path, false).is_whitelist()
-        };
 
-        if matches {
-            candidates.push((entry, depth));
-        }
-    }
+            if matches { Some((entry, depth)) } else { None }
+        })
+        .collect();
 
     // Sort the candidates by depth, source file, and line number
-    candidates.sort_by(|a, b| {
+    candidates.sort_unstable_by(|a, b| {
         let a_entry = a.0;
         let a_depth = a.1;
         let b_entry = b.0;