fix(index): let Go to File find git-ignored files such as .env (#1313)

The index walker used the ignore crate, which drops ignored files before we see them, and the watcher dropped their events too, so git-ignored files such as .env were missing from the index and Go to File, the Files tab and @ mentions could not reach them in any scope. As in IDEA, ignored folders stay out of the project but ignored files stay in it: each walked folder is also listed and the files the walker skipped are indexed by name only (no read, hash or symbols), the ignored flag is stored (index schema 3) so a file whose rules flip is re-parsed or dropped on the next scan, and the watcher reports ignored files in a separate list that only the index and open editors use (Local History, deployment, LSP and fsChanged see the same events as before). Watcher updates classify files by listing their folder with the scan's walker, so nested, global and info/exclude rules apply the same way.

Co-authored-by: jaw52 <[email protected]>

crates/ide-host/src/project.rs

@@ -305,12 +305,13 @@ impl Host {
                 sink.clone(),
                 Box::new(move |batch| {
                     let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();
-                    index.update(&changed, &batch.removed);
+                    let (ignored, ignored_gone) = ignored_changes(batch);
+                    index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
                     kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));
                     lsp.project_files_changed(batch.created.iter().chain(&batch.removed));
                     lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed, &batch.excluded_dirs);
                     // Atomic saves by external tools surface as `created`.
-                    documents.on_disk_changed(&changed);
+                    documents.on_disk_changed(&[&changed[..], &ignored].concat());
                     // A framework's root marker (`angular.json`) created or deleted: its
                     // templates gain or lose their mode. Markers in `node_modules` only
                     // count here when the folder isn't excluded (it is by default).
@@ -961,6 +962,11 @@ const HISTORY_BATCH_LIMIT: usize = 500;
 
 /// Local History for changes made outside the IDE (other tools, VCS, deletions).
 /// Contents equal to the last snapshot (e.g. the IDE's own saves) are skipped.
+/// The batch's ignored files (`.env`), split into those still on disk and those removed.
+fn ignored_changes(batch: &ide_vfs::FsBatch) -> (Vec<PathBuf>, Vec<PathBuf>) {
+    batch.ignored.iter().cloned().partition(|p| p.symlink_metadata().is_ok())
+}
+
 fn record_external_changes(history: &LocalHistory, changed: &[PathBuf], removed: &[PathBuf]) {
     for path in changed.iter().take(HISTORY_BATCH_LIMIT) {
         if let Err(e) = history.record_file(path, "External change", false) {
@@ -1045,11 +1051,12 @@ fn content_root_watcher(
         sink.clone(),
         Box::new(move |batch| {
             let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();
-            index.update(&changed, &batch.removed);
+            let (ignored, ignored_gone) = ignored_changes(batch);
+            index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
             if let Some(bridge) = &kotlin_bridge {
                 bridge.files_changed(changed.iter().chain(&batch.removed));
             }
-            documents.on_disk_changed(&changed);
+            documents.on_disk_changed(&[&changed[..], &ignored].concat());
             record_external_changes(&history, &changed, &batch.removed);
         }),
     )

crates/ide-index/src/data.rs

@@ -40,6 +40,8 @@ pub(crate) struct FileRecord {
     pub size: u64,
     pub hash: [u8; 32],
     pub symbols: Vec<StoredSymbol>,
+    /// Matched by an ignore file: listed by name only (no hash, no symbols).
+    pub ignored: bool,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -72,6 +74,7 @@ pub(crate) struct FileEntry {
     pub size: u64,
     pub hash: [u8; 32],
     pub symbols: Box<[Sym]>,
+    pub ignored: bool,
 }
 
 impl FileEntry {
@@ -100,6 +103,7 @@ impl FileEntry {
             size: record.size,
             hash: record.hash,
             symbols,
+            ignored: record.ignored,
         }
     }
 
@@ -126,8 +130,14 @@ impl FileEntry {
                     range: s.range,
                 })
                 .collect(),
+            ignored: self.ignored,
         }
     }
+
+    /// Whether the entry is out of date for `found` on disk.
+    pub(crate) fn stale_for(&self, found: &crate::filter::Found) -> bool {
+        self.mtime != found.mtime || self.size != found.size || self.ignored != found.ignored
+    }
 }
 
 #[derive(Default)]

crates/ide-index/src/filter.rs

@@ -1,10 +1,16 @@
 //! Which paths belong in the index: `.gitignore`/`.ignore` rules (via the
 //! `ignore` crate) plus the user's `files.exclude` globs, below the project root
 //! and the extra content roots (Project Structure).
+//!
+//! Like IDEA, ignored directories are left out entirely, while ignored files in
+//! the remaining directories (`.env`) are listed by name only, so Go to File finds
+//! them but their symbols stay out of the index.
 
 use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
 use ignore::gitignore::{Gitignore, GitignoreBuilder};
 use ignore::{WalkBuilder, WalkState};
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc;
@@ -57,11 +63,25 @@ fn rel_string(rel: &Path) -> String {
     out
 }
 
+/// Whether `path` below `root` matches the exclude globs.
+fn glob_excluded(excludes: &GlobSet, root: &Path, path: &Path) -> bool {
+    match path.strip_prefix(root) {
+        Ok(rel) if !rel.as_os_str().is_empty() => {
+            let rel = rel.to_string_lossy();
+            let rel = if std::path::MAIN_SEPARATOR == '/' { rel } else { rel.replace('\\', "/").into() };
+            excludes.is_match(rel.as_ref())
+        }
+        _ => false,
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct Found {
     pub path: PathBuf,
     pub mtime: u64,
     pub size: u64,
+    /// Matched by an ignore file: listed by name only.
+    pub ignored: bool,
 }
 
 pub(crate) fn mtime_of(meta: &std::fs::Metadata) -> u64 {
@@ -177,8 +197,9 @@ impl PathFilter {
         ALWAYS_SKIP.contains(&name)
     }
 
-    /// Whether a path reported by the watcher should be ignored (outside the
-    /// root, inside an excluded/ignored directory, or ignored itself).
+    /// Whether a path reported by the watcher should be left out (outside the
+    /// root, excluded, or an ignored directory or inside one). Ignored files
+    /// elsewhere stay in, listed by name only.
     pub(crate) fn is_excluded(&self, path: &Path, is_dir: bool) -> bool {
         let Some((base, _, gitignore)) = self.base_of(path) else { return true };
         let rel = path.strip_prefix(base).map(rel_string).unwrap_or_default();
@@ -198,16 +219,27 @@ impl PathFilter {
                 return true;
             }
         }
-        gitignore.matched_path_or_any_parents(path, is_dir).is_ignore()
+        let dir = if is_dir { Some(path) } else { path.parent().filter(|p| *p != base) };
+        dir.is_some_and(|d| gitignore.matched_path_or_any_parents(d, true).is_ignore())
     }
 
     /// All indexable files at or below `dir`, walked in parallel.
     /// Stops early (returning what was found so far) once `cancel` is set.
     pub(crate) fn walk(&self, dir: &Path, cancel: &AtomicBool) -> Vec<Found> {
+        self.walk_to(dir, None, cancel)
+    }
+
+    /// The indexable files directly in `dir`, classified by the same rules as [`Self::walk`].
+    pub(crate) fn list_dir(&self, dir: &Path) -> Vec<Found> {
+        self.walk_to(dir, Some(1), &AtomicBool::new(false))
+    }
+
+    fn walk_to(&self, dir: &Path, max_depth: Option<usize>, cancel: &AtomicBool) -> Vec<Found> {
         let (tx, rx) = mpsc::channel::<Vec<Found>>();
         let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
         let root = root.to_path_buf();
         let excludes = self.excludes.clone();
+        let (walk_root, walk_excludes) = (root.clone(), excludes.clone());
         let walker = WalkBuilder::new(dir)
             .hidden(false)
             .parents(true)
@@ -217,41 +249,63 @@ impl PathFilter {
             .git_exclude(true)
             .require_git(ide_core::ignored::inside_git_repo(dir))
             .follow_links(false)
+            .max_depth(max_depth)
             .filter_entry(move |e| {
                 let name = e.file_name().to_string_lossy();
-                if Self::skip_name(&name) {
-                    return false;
-                }
-                match e.path().strip_prefix(&root) {
-                    Ok(rel) if !rel.as_os_str().is_empty() => {
-                        let rel = rel.to_string_lossy();
-                        let rel = if std::path::MAIN_SEPARATOR == '/' { rel } else { rel.replace('\\', "/").into() };
-                        !excludes.is_match(rel.as_ref())
-                    }
-                    _ => true,
-                }
+                !Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
             })
             .build_parallel();
         walker.run(|| {
+            let (root, excludes) = (&root, &excludes);
             let mut batch = Batch { tx: tx.clone(), items: Vec::with_capacity(256) };
             Box::new(move |entry| {
                 if cancel.load(Ordering::Relaxed) {
                     return WalkState::Quit;
                 }
                 let Ok(entry) = entry else { return WalkState::Continue };
-                if entry.file_type().is_some_and(|t| t.is_file())
+                let Some(file_type) = entry.file_type() else { return WalkState::Continue };
+                if file_type.is_dir() && max_depth.is_none_or(|max| entry.depth() < max) {
+                    // The walker drops ignored files unseen: list every file of a
+                    // walked directory; those the walker doesn't report are ignored.
+                    let Ok(children) = std::fs::read_dir(entry.path()) else { return WalkState::Continue };
+                    for child in children.flatten() {
+                        let path = child.path();
+                        if child.file_type().is_ok_and(|t| t.is_file())
+                            && !Self::skip_name(&child.file_name().to_string_lossy())
+                            && !glob_excluded(excludes, root, &path)
+                            && let Ok(meta) = child.metadata()
+                        {
+                            batch.items.push(Found { path, mtime: mtime_of(&meta), size: meta.len(), ignored: true });
+                        }
+                    }
+                } else if file_type.is_file()
                     && let Ok(meta) = entry.metadata()
                 {
-                    batch.items.push(Found { path: entry.into_path(), mtime: mtime_of(&meta), size: meta.len() });
-                    if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {
-                        return WalkState::Quit;
-                    }
+                    batch.items.push(Found {
+                        path: entry.into_path(),
+                        mtime: mtime_of(&meta),
+                        size: meta.len(),
+                        ignored: false,
+                    });
+                }
+                if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {
+                    return WalkState::Quit;
                 }
                 WalkState::Continue
             })
         });
         drop(tx);
-        rx.into_iter().flatten().collect()
+        // Each file comes once from its directory listing and, unless ignored, once from the walker.
+        let mut by_path: HashMap<PathBuf, Found> = HashMap::new();
+        for f in rx.into_iter().flatten() {
+            match by_path.entry(f.path.clone()) {
+                Entry::Occupied(mut e) => e.get_mut().ignored &= f.ignored,
+                Entry::Vacant(e) => {
+                    e.insert(f);
+                }
+            }
+        }
+        by_path.into_values().collect()
     }
 }
 
@@ -311,6 +365,84 @@ mod tests {
         assert!(!filter.is_excluded(&root.join("src/new.rs"), false));
     }
 
+    #[test]
+    fn ignored_files_are_listed_but_ignored_directories_are_not() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dunce::canonicalize(dir.path()).unwrap();
+        for f in [
+            ".env",
+            "src/a.rs",
+            "src/debug.log",
+            "src/local/secrets.json",
+            "pkg/.gitignore",
+            "pkg/gen.rs",
+            "pkg/keep.rs",
+            "build/out.rs",
+            "build/nested/deep.rs",
+            "logs/app.log",
+            "node_modules/x/.env",
+            "src/.DS_Store",
+            "src/.git",
+        ] {
+            touch(&root, f);
+        }
+        std::fs::write(
+            root.join(".gitignore"),
+            ".env
+*.log
+build/
+logs/
+src/local/
+",
+        )
+        .unwrap();
+        std::fs::write(
+            root.join("pkg/.gitignore"),
+            "gen.rs
+",
+        )
+        .unwrap();
+        let filter = PathFilter::new(&root, &vec![].into(), &["**/node_modules".into(), "**/.DS_Store".into()]);
+        let mut found: Vec<(String, bool)> = filter
+            .walk(&root, &AtomicBool::new(false))
+            .iter()
+            .filter_map(|f| Some((filter.rel(&f.path)?, f.ignored)))
+            .collect();
+        found.sort();
+        let expected = [
+            (".env", true),
+            (".gitignore", false),
+            ("pkg/.gitignore", false),
+            ("pkg/gen.rs", true),
+            ("pkg/keep.rs", false),
+            ("src/a.rs", false),
+            ("src/debug.log", true),
+        ];
+        assert_eq!(found, expected.map(|(p, i)| (p.to_owned(), i)));
+
+        // One directory at a time (watcher updates): same classification, no descent.
+        let mut listed: Vec<(String, bool)> =
+            filter.list_dir(&root.join("pkg")).iter().filter_map(|f| Some((filter.rel(&f.path)?, f.ignored))).collect();
+        listed.sort();
+        let expected = [("pkg/.gitignore", false), ("pkg/gen.rs", true), ("pkg/keep.rs", false)];
+        assert_eq!(listed, expected.map(|(p, i)| (p.to_owned(), i)));
+        let top: Vec<String> = filter.list_dir(&root).iter().filter_map(|f| filter.rel(&f.path)).collect();
+        assert!(top.iter().all(|p| !p.contains('/')), "{top:?}");
+
+        for (rel, excluded) in [
+            (".env", false),
+            ("src/new.log", false),
+            ("src/new.rs", false),
+            ("build/x.rs", true),
+            ("logs/app.log", true),
+            ("src/local/x.json", true),
+        ] {
+            assert_eq!(filter.is_excluded(&root.join(rel), false), excluded, "{rel}");
+        }
+        assert!(filter.is_excluded(&root.join("build"), true));
+        assert!(!filter.is_excluded(&root.join("src"), true));
+    }
+
     #[test]
     fn a_nested_repository_is_not_hidden_by_the_outer_repositorys_gitignore() {
         let dir = tempfile::tempdir().unwrap();

crates/ide-index/src/store.rs

@@ -8,7 +8,7 @@ use std::path::Path;
 const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
 const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
 /// Bump when [`FileRecord`] or its encoding changes.
-const SCHEMA: &str = "openidea-index-2";
+const SCHEMA: &str = "openidea-index-3";
 
 type Result<T> = std::result::Result<T, String>;
 

crates/ide-index/src/tests.rs

@@ -293,6 +293,56 @@ fn binary_and_huge_files_are_listed_without_symbols() {
     assert_eq!(idx.status().symbols, 0);
 }
 
+#[test]
+fn go_to_file_finds_ignored_files_but_not_their_symbols() {
+    let fx = Fixture::new(&[
+        (".gitignore", ".env\n*.local.ts\ndist/\n"),
+        (".env", "SECRET=1\n"),
+        ("src/app.ts", "export function app() {}\n"),
+        ("src/config.local.ts", "export function localOnly() {}\n"),
+        ("dist/bundle.js", "function bundled() {}\n"),
+    ]);
+    let idx = fx.open();
+    assert_eq!(files(&idx, ".env"), vec![".env"], "the reported case: a git-ignored root file");
+    assert_eq!(files(&idx, "config.local"), vec!["src/config.local.ts"]);
+    assert!(files(&idx, "bundle").is_empty(), "ignored directories stay out");
+    assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty(), "ignored files are listed by name only");
+    assert_eq!(symbols(&idx, "app", SymbolFilter::All), vec!["app"]);
+
+    // Watcher updates keep the distinction.
+    let fresh = fx.write("src/fresh.local.ts", "export function freshLocal() {}\n");
+    let bundled = fx.write("dist/more.js", "function more() {}\n");
+    idx.update(&[fresh, bundled], &[]);
+    assert!(idx.wait_idle(WAIT));
+    assert_eq!(files(&idx, "fresh.local"), vec!["src/fresh.local.ts"]);
+    assert!(symbols(&idx, "freshLocal", SymbolFilter::All).is_empty());
+    assert!(files(&idx, "more.js").is_empty());
+
+    // Nested ignore files apply to watcher updates as they do to the scan.
+    fx.write("pkg/.gitignore", "gen.ts\n");
+    let generated = fx.write("pkg/gen.ts", "export function generatedThing() {}\n");
+    let kept = fx.write("pkg/kept.ts", "export function keptThing() {}\n");
+    idx.update(&[generated, kept], &[]);
+    assert!(idx.wait_idle(WAIT));
+    assert_eq!(files(&idx, "pkg/gen"), vec!["pkg/gen.ts"]);
+    assert!(symbols(&idx, "generatedThing", SymbolFilter::All).is_empty());
+    assert_eq!(symbols(&idx, "keptThing", SymbolFilter::All), vec!["keptThing"]);
+    drop(idx);
+
+    // No longer ignored: the next scan parses it although its mtime is unchanged.
+    std::fs::write(fx.root.join(".gitignore"), ".env\ndist/\n").unwrap();
+    let idx = fx.open();
+    assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), vec!["localOnly"]);
+    assert_eq!(files(&idx, ".env"), vec![".env"]);
+    drop(idx);
+
+    // Ignored again: its symbols are dropped.
+    std::fs::write(fx.root.join(".gitignore"), "*.local.ts\n").unwrap();
+    let idx = fx.open();
+    assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());
+    assert_eq!(files(&idx, "bundle"), vec!["dist/bundle.js"]);
+}
+
 #[test]
 fn second_window_on_same_project_works_in_memory() {
     let fx = sample();

crates/ide-index/src/worker.rs

@@ -2,13 +2,13 @@
 //! updates queued by the watcher.
 
 use crate::data::{FileEntry, FileRecord, IndexData, StoredSymbol};
-use crate::filter::{Found, PathFilter, mtime_of};
+use crate::filter::{Found, PathFilter};
 use crate::store::Store;
 use ide_core::{IdeEvent, SharedSink, TaskId};
 use ide_language::{LanguageRegistry, Syntax};
 use parking_lot::{Condvar, Mutex, RwLock};
 use rayon::prelude::*;
-use std::collections::{HashSet, VecDeque};
+use std::collections::{HashMap, HashSet, VecDeque};
 use std::io::Read;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -233,10 +233,7 @@ impl Shared {
         let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
         let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
             let d = self.data.read();
-            let todo = found
-                .iter()
-                .filter(|f| d.get(&f.path).is_none_or(|e| e.mtime != f.mtime || e.size != f.size))
-                .collect();
+            let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
             let stale = d.paths().filter(|p| !seen.contains(p.as_path())).cloned().collect();
             (todo, stale)
         };
@@ -311,6 +308,7 @@ impl Shared {
                         let mut rec = d.get(&f.path)?.record();
                         rec.mtime = f.mtime;
                         rec.size = f.size;
+                        rec.ignored = f.ignored;
                         Some((rel, rec, f.path.clone()))
                     }
                     Extracted::New(rec) => Some((rel, rec, f.path.clone())),
@@ -342,8 +340,8 @@ impl Shared {
     }
 
     fn extract(&self, f: &Found, prev_hash: Option<[u8; 32]>) -> Extracted {
-        let mut rec = FileRecord { mtime: f.mtime, size: f.size, ..Default::default() };
-        if f.size > MAX_SYMBOL_FILE {
+        let mut rec = FileRecord { mtime: f.mtime, size: f.size, ignored: f.ignored, ..Default::default() };
+        if f.ignored || f.size > MAX_SYMBOL_FILE {
             return Extracted::New(rec);
         }
         let mut bytes = Vec::with_capacity(f.size as usize);
@@ -420,6 +418,7 @@ impl Shared {
 
         let mut files: Vec<Found> = Vec::new();
         let mut seen = HashSet::new();
+        let mut by_dir: HashMap<PathBuf, HashSet<PathBuf>> = HashMap::new();
         for path in changed {
             if !seen.insert(path.clone()) {
                 continue;
@@ -430,16 +429,19 @@ impl Shared {
             }
             if meta.is_dir() {
                 files.extend(filter.walk(&path, &self.cancelled));
-            } else if meta.is_file() {
-                files.push(Found { mtime: mtime_of(&meta), size: meta.len(), path });
+            } else if meta.is_file()
+                && let Some(dir) = path.parent()
+            {
+                by_dir.entry(dir.to_owned()).or_default().insert(path);
             }
         }
+        // Listing the folder applies every ignore file (nested, global) to tell ignored files apart.
+        for (dir, wanted) in by_dir {
+            files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
+        }
         let files: Vec<Found> = {
             let d = self.data.read();
-            files
-                .into_iter()
-                .filter(|f| d.get(&f.path).is_none_or(|e| e.mtime != f.mtime || e.size != f.size))
-                .collect()
+            files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
         };
         if !files.is_empty() {
             touched = true;
@@ -457,7 +459,7 @@ impl Shared {
                     .filter(|p| before.detect(p, None) != self.languages.detect(p, None))
                     .filter_map(|p| {
                         let e = d.get(p)?;
-                        Some(Found { path: p.clone(), mtime: e.mtime, size: e.size })
+                        Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
                     })
                     .collect()
             };

crates/ide-vfs/src/lib.rs

@@ -325,6 +325,11 @@ pub struct FsBatch {
     /// Folders holding changes filtered out as excluded or ignored. Only a view already
     /// showing such a folder cares, so they don't count as worktree changes.
     pub excluded_dirs: Vec<PathBuf>,
+    /// Files changed, created or removed that an ignore rule matches while their folder
+    /// is not ignored (`.env`). Kept apart from the worktree changes above (no Local
+    /// History, deployment or `fsChanged`), but the index lists them and open editors
+    /// follow them, like IDEA, where only ignored folders leave the project.
+    pub ignored: Vec<PathBuf>,
 }
 
 impl FsBatch {
@@ -334,6 +339,7 @@ impl FsBatch {
             && self.removed.is_empty()
             && self.vcs.is_empty()
             && self.excluded_dirs.is_empty()
+            && self.ignored.is_empty()
     }
 }
 

crates/ide-vfs/src/watch.rs

@@ -531,6 +531,13 @@ impl EventFilter {
             && !self.gitignore.is_ignored(path, is_dir)
     }
 
+    /// Whether a filtered-out file is ignored by a rule on the file itself, in a folder
+    /// that is neither excluded nor ignored.
+    fn is_ignored_file(&self, path: &Path, rel: &Path) -> bool {
+        !self.excludes.read().is_excluded(rel)
+            && path.parent().is_some_and(|dir| dir == self.root || !self.gitignore.is_ignored(dir, true))
+    }
+
     fn classify(&self, path: &Path, change: Change, out: &mut BTreeMap<PathBuf, Change>) {
         let rel = match path.strip_prefix(&self.root) {
             Ok(rel) if rel.as_os_str().is_empty() => return,
@@ -642,6 +649,9 @@ impl EventFilter {
                     if change != Change::Modified {
                         excluded_dirs.extend(path.parent().map(Path::to_path_buf));
                     }
+                    if !is_dir && self.is_ignored_file(&path, rel) {
+                        batch.ignored.push(path);
+                    }
                     continue;
                 }
             }
@@ -700,6 +710,7 @@ mod tests {
         assert_eq!(batch.vcs, vec![root.join(".git/HEAD"), root.join(".git/refs/heads/feature")]);
         assert_eq!(batch.modified, vec![root.join("kept.txt")]);
         assert_eq!(batch.removed, vec![root.join("from.txt"), root.join("gone.txt"), root.join("old.txt")]);
+        assert_eq!(batch.ignored, vec![root.join("debug.log")], "ignored files are reported apart");
     }
 
     #[test]
@@ -751,6 +762,20 @@ mod tests {
         ]);
         assert!(batch.created.is_empty() && batch.modified.is_empty() && batch.removed.is_empty(), "{batch:?}");
         assert_eq!(batch.excluded_dirs, vec![root.clone(), root.join("dist"), root.join("target/debug")]);
+        assert_eq!(batch.ignored, vec![root.join("debug.log")], "only the ignored file outside ignored folders");
+
+        // An ignored file's edit and removal reach the index too (nothing else changes).
+        let modify = EventKind::Modify(ModifyKind::Data(DataChange::Content));
+        let batch = filter.batch(&[ev(modify, vec![root.join("debug.log")])]);
+        assert_eq!(batch.ignored, vec![root.join("debug.log")]);
+        assert!(!batch.is_empty() && batch.excluded_dirs.is_empty());
+        std::fs::remove_file(root.join("debug.log")).unwrap();
+        let batch = filter.batch(&[
+            ev(EventKind::Remove(RemoveKind::File), vec![root.join("debug.log")]),
+            ev(EventKind::Remove(RemoveKind::File), vec![root.join("dist/app.js")]),
+        ]);
+        // A removed path can't tell file from folder: it goes out as a removal, as before.
+        assert_eq!(batch.removed, vec![root.join("debug.log")]);
 
         // Sibling files in unignored directories still come through.
         let batch = filter.batch(&[ev(create_file, vec![root.join("src/main.rs")])]);
@@ -801,6 +826,7 @@ mod tests {
             |paths: &[&str]| -> Vec<DebouncedEvent> { paths.iter().map(|p| ev(modify, vec![root.join(p)])).collect() };
         let (batch, rules) = filter.batch_detailed(&touch(&["pkg/a.tmp", "pkg/gen/x.rs", "pkg/keep.rs", "b.tmp"]));
         assert_eq!(batch.modified, vec![root.join("b.tmp"), root.join("pkg/keep.rs")]);
+        assert_eq!(batch.ignored, vec![root.join("pkg/a.tmp")], "nested rules, but not inside ignored folders");
         assert!(rules.is_empty());
         assert!(!filter.should_watch_dir(&root.join("pkg/gen")));
 
@@ -818,7 +844,8 @@ mod tests {
         std::fs::create_dir_all(root.join(".git/info")).unwrap();
         std::fs::write(root.join(".git/info/exclude"), "b.tmp\n").unwrap();
         let (batch, rules) = filter.batch_detailed(&touch(&[".git/info/exclude", "b.tmp"]));
-        assert!(batch.is_empty(), "{batch:?}");
+        assert!(batch.modified.is_empty() && batch.vcs.is_empty(), "{batch:?}");
+        assert_eq!(batch.ignored, vec![root.join("b.tmp")]);
         assert_eq!(rules, vec![root.clone()]);
     }