fix ci

Author: dmtrKovalenko

crates/fff-core/src/background_watcher.rs

@@ -579,13 +579,6 @@ fn handle_debounced_events(
 
         files_to_update_git_status.reserve(paths_to_add_or_modify.len());
         for path in &paths_to_add_or_modify {
-            // Double-check existence: the debouncer may deliver a Modify event
-            // for a path that was deleted between event emission and processing
-            // (Create+Remove merged into just Create by the debouncer).
-            if !path.exists() {
-                picker.remove_file_by_path(path);
-                continue;
-            }
             if picker.handle_create_or_modify(path).is_some() {
                 files_to_update_git_status.push(path.to_path_buf());
             } else {
@@ -594,40 +587,12 @@ fn handle_debounced_events(
         }
 
         overflow_count = picker.get_overflow_files().len();
-
-        // Reconcile overflow files: stat-check each live overflow file and
-        // tombstone any that no longer exist on disk. This handles deletions
-        // where the debouncer swallowed the Remove event.
-        if overflow_count > 0 {
-            let base_path = picker.base_path().to_path_buf();
-            let stale: Vec<PathBuf> = picker
-                .get_overflow_files()
-                .iter()
-                .filter(|f| !f.is_deleted())
-                .filter_map(|f| {
-                    let abs = f.absolute_path(&*picker, &base_path);
-                    (!abs.exists()).then_some(abs)
-                })
-                .collect();
-
-            for path in &stale {
-                picker.remove_file_by_path(path);
-            }
-            if !stale.is_empty() {
-                overflow_count = picker.get_overflow_files().len();
-            }
-        }
     }
 
     info!(
         files_updated = files_to_update_git_status.len(),
         overflow_count, "File index changes applied",
     );
-
-    // Reconcile overflow files unconditionally on every batch: stat-check
-    // each live overflow file and tombstone any that no longer exist on disk.
-    // This is the only reliable way to detect deletions when the debouncer
-    // coalesces Create+Remove for the same path into nothing.
     if need_full_rescan || overflow_count > MAX_OVERFLOW_FILES {
         info!("Watcher faced limit of index overflow. Triggering rescan");
         if let Err(e) = shared_picker.trigger_full_rescan_async(shared_frecency) {
@@ -679,50 +644,47 @@ fn handle_debounced_events(
         }
     }
 
-    // Git status updates are IO-heavy (reads .git/index, stats files) and
-    // not on the critical path for search correctness. Spawn them on the
-    // background pool so the debouncer handler returns immediately and can
-    // process the next event batch without waiting for git.
-    if need_full_git_rescan || !files_to_update_git_status.is_empty() {
-        let sp = shared_picker.clone();
-        let sf = shared_frecency.clone();
-        let git_workdir = repo.as_ref().map(|r| {
-            r.workdir()
-                .unwrap_or_else(|| r.path())
-                .to_path_buf()
-        });
-        let full_rescan = need_full_git_rescan;
-        let need_picker_rescan = need_full_rescan;
-        let files = files_to_update_git_status;
+    // do not try to update the paths if we anyway going to rescan everythign from scracth
+    if !need_full_rescan && (need_full_git_rescan || !files_to_update_git_status.is_empty()) {
+        let git_workdir = repo
+            .as_ref()
+            .map(|r| r.workdir().unwrap_or_else(|| r.path()).to_path_buf());
+
+        let shared_picker = shared_picker.clone();
+        let shared_frecency = shared_frecency.clone();
 
+        // git status query even with a pathspec could be really slow, if we do this syncrhronously
+        // within the event handler, we actually risk of forming a snow ball of conflicting events
         crate::file_picker::BACKGROUND_THREAD_POOL.spawn(move || {
             let Some(git_path) = git_workdir else { return };
             let Ok(repo) = Repository::open(&git_path) else {
                 error!("Failed to open git repo for async status update");
                 return;
             };
 
-            if full_rescan && !need_picker_rescan {
+            if need_full_git_rescan && !need_full_rescan {
                 info!("Async: triggering full git rescan");
-                if let Err(e) = sp.refresh_git_status(&sf) {
+                if let Err(e) = shared_picker.refresh_git_status(&shared_frecency) {
                     error!("Failed to refresh git status: {:?}", e);
                 }
             }
 
-            if !files.is_empty() && !full_rescan {
-                info!("Async: fetching git status for {} files", files.len());
-                let status = match GitStatusCache::git_status_for_paths(&repo, &files) {
+            if !files_to_update_git_status.is_empty() {
+                let status = match GitStatusCache::git_status_for_paths(
+                    &repo,
+                    &files_to_update_git_status,
+                ) {
                     Ok(s) => s,
                     Err(e) => {
                         error!("Failed to query git status: {:?}", e);
                         return;
                     }
                 };
 
-                if let Ok(mut guard) = sp.write()
+                if let Ok(mut guard) = shared_picker.write()
                     && let Some(ref mut picker) = *guard
                 {
-                    if let Err(e) = picker.update_git_statuses(status, &sf) {
+                    if let Err(e) = picker.update_git_statuses(status, &shared_frecency) {
                         error!("Failed to update git statuses: {:?}", e);
                     } else {
                         info!("Async: git statuses updated");

crates/fff-core/src/bigram_filter.rs

@@ -596,13 +596,7 @@ impl BigramOverlay {
     }
 }
 
-/// Per-file size cap for bigram indexing. Doubles as the `is_indexable`
-/// cutoff in the finalize-sort: files over this size are pushed past
-/// `indexable_count` and unconditionally scanned at grep time instead of
-/// being bigram-prefiltered. Unifying the two caps guarantees that every
-/// file inside the indexed region gets *full* bigram coverage, so the
-/// prefilter never produces false negatives on partial-content files.
-pub(crate) const BIGRAM_CONTENT_CAP: usize = 2 * 1024 * 1024;
+pub(crate) const MAX_INDEXABLE_FILE_SIZE: usize = 2 * 1024 * 1024;
 const BIGRAM_CHUNK_FILES: usize = 4 * 64;
 
 /// Sparse-column cutoff for the skip-1 sub-index. Rare skip columns add
@@ -611,16 +605,14 @@ const BIGRAM_CHUNK_FILES: usize = 4 * 64;
 const SKIP_INDEX_MIN_DENSITY_PCT: u32 = 12;
 
 thread_local! {
-    /// Per-rayon-worker reusable read buffer. Allocated via `vec!` to avoid
-    /// materializing the 2 MiB array on the worker stack (`Box::new([0u8; N])`
-    /// constructs the array in the current frame first, which overflows the
-    /// default 2 MiB rayon worker stack).
+    /// Reusable read buffer that is allocated per thread and used for reading files
     static READ_BUF: std::cell::RefCell<Box<[u8]>> =
-        std::cell::RefCell::new(vec![0u8; BIGRAM_CONTENT_CAP].into_boxed_slice());
+        std::cell::RefCell::new(vec![0u8; MAX_INDEXABLE_FILE_SIZE].into_boxed_slice());
 }
 
 /// reads a chunk for bigram either from new warmed up cache or from the file directly
 #[inline]
+#[allow(clippy::too_many_arguments)]
 fn read_bigram_chunk<'a>(
     file: &'a crate::types::FileItem,
     base_fd: libc::c_int,
@@ -640,10 +632,10 @@ fn read_bigram_chunk<'a>(
             return None;
         }
 
-        return Some(&cached[..cached.len().min(BIGRAM_CONTENT_CAP)]);
+        return Some(&cached[..cached.len().min(MAX_INDEXABLE_FILE_SIZE)]);
     }
 
-    let want = (file.size as usize).min(BIGRAM_CONTENT_CAP);
+    let want = (file.size as usize).min(MAX_INDEXABLE_FILE_SIZE);
     let filled = file.read_trimmed_into_buf(base_fd, base_path, arena, path_buf, &mut buf[..want]);
     if filled == 0 {
         return None;
@@ -724,7 +716,7 @@ pub(crate) fn build_bigram_index(
 
     // in progress bigram walk + rust's ignore crate allocates shit ton of garbage memory
     // all custom allocators would think this is available resource while we do not allocate
-    // afte the sync, so it's very important to let the unused memory go back to the OS
+    // after the sync, so it's very important to let the unused memory go back to the OS
     crate::file_picker::hint_allocator_collect();
 
     index