fix: apply --watch-exclude filter to file change events

Previously, `--watch-exclude` only filtered paths when registering them
with the OS file watcher. When a directory was watched recursively
(e.g. `--watch=.`), the OS reported changes to all files within it,
including excluded ones, because the exclude check was never applied to
incoming change notifications.

This fix passes the exclude set into the `new_watcher()` callback and
filters changed paths before they enter the debounce channel, ensuring
excluded files never trigger a restart.

Closes #26217

Author: AprilNEA

cli/util/file_watcher.rs

@@ -303,7 +303,7 @@ where
   let initial_cwd = std::env::current_dir()
     .ok()
     .and_then(|path| deno_path_util::url_from_directory_path(&path).ok());
-  let exclude_set = flags.resolve_watch_exclude_set()?;
+  let exclude_set = Arc::new(flags.resolve_watch_exclude_set()?);
   let (paths_to_watch_tx, mut paths_to_watch_rx) =
     tokio::sync::mpsc::unbounded_channel();
   let (restart_tx, mut restart_rx) = tokio::sync::mpsc::unbounded_channel();
@@ -354,7 +354,7 @@ where
       tokio::task::yield_now().await;
     }
 
-    let mut watcher = new_watcher(watcher_sender.clone())?;
+    let mut watcher = new_watcher(watcher_sender.clone(), exclude_set.clone())?;
     consume_paths_to_watch(&mut watcher, &mut paths_to_watch_rx, &exclude_set);
 
     let receiver_future = async {
@@ -433,6 +433,7 @@ where
 
 fn new_watcher(
   sender: Arc<mpsc::UnboundedSender<Vec<PathBuf>>>,
+  exclude_set: Arc<PathOrPatternSet>,
 ) -> Result<RecommendedWatcher, AnyError> {
   Ok(Watcher::new(
     move |res: Result<NotifyEvent, NotifyError>| {
@@ -447,13 +448,16 @@ fn new_watcher(
         return;
       }
 
-      let paths = event
+      let paths: Vec<PathBuf> = event
         .paths
         .iter()
         .filter_map(|path| canonicalize_path(path).ok())
+        .filter(|path| !exclude_set.matches_path(path))
         .collect();
 
-      sender.send(paths).unwrap();
+      if !paths.is_empty() {
+        sender.send(paths).unwrap();
+      }
     },
     Default::default(),
   )?)

tests/integration/watcher_tests.rs

@@ -1743,6 +1743,133 @@ async fn run_watch_with_excluded_paths() {
   check_alive_then_kill(child);
 }
 
+/// Regression test for https://github.com/denoland/deno/issues/26217
+/// When using `--watch=.` (directory), excluded files within that directory
+/// should not trigger restarts.
+#[test(flaky)]
+async fn run_watch_directory_with_excluded_file() {
+  let t = TempDir::new();
+
+  let file_to_watch = t.path().join("file_to_watch.js");
+  file_to_watch.write("console.log('hello');");
+
+  let file_to_exclude = t.path().join("file_to_exclude.txt");
+  file_to_exclude.write("original content");
+
+  let mut child = util::deno_cmd()
+    .current_dir(t.path())
+    .arg("run")
+    .arg("--watch=.")
+    .arg("--watch-exclude=file_to_exclude.txt")
+    .arg("-L")
+    .arg("debug")
+    .arg(&file_to_watch)
+    .env("NO_COLOR", "1")
+    .piped_output()
+    .spawn()
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
+
+  wait_contains("hello", &mut stdout_lines).await;
+  wait_contains("finished", &mut stderr_lines).await;
+
+  // Modify excluded file - should NOT trigger restart
+  file_to_exclude.write("modified content");
+
+  // Modify watched file - should trigger restart
+  file_to_watch.write("console.log('restarted');");
+  wait_contains("Restarting", &mut stderr_lines).await;
+  wait_contains("restarted", &mut stdout_lines).await;
+
+  check_alive_then_kill(child);
+}
+
+/// When using `--watch=.`, excluded glob patterns should filter out matching
+/// files from triggering restarts.
+#[test(flaky)]
+async fn run_watch_directory_with_excluded_glob_pattern() {
+  let t = TempDir::new();
+
+  let file_to_watch = t.path().join("app.js");
+  file_to_watch.write("console.log('hello');");
+
+  let log_file = t.path().join("debug.log");
+  log_file.write("log line 1");
+
+  let tmp_file = t.path().join("temp.log");
+  tmp_file.write("tmp data");
+
+  let mut child = util::deno_cmd()
+    .current_dir(t.path())
+    .arg("run")
+    .arg("--watch=.")
+    .arg("--watch-exclude=*.log")
+    .arg("-L")
+    .arg("debug")
+    .arg(&file_to_watch)
+    .env("NO_COLOR", "1")
+    .piped_output()
+    .spawn()
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
+
+  wait_contains("hello", &mut stdout_lines).await;
+  wait_contains("finished", &mut stderr_lines).await;
+
+  // Modify .log files - should NOT trigger restart
+  log_file.write("log line 2");
+  tmp_file.write("tmp data updated");
+
+  // Modify watched file - should trigger restart
+  file_to_watch.write("console.log('updated');");
+  wait_contains("Restarting", &mut stderr_lines).await;
+  wait_contains("updated", &mut stdout_lines).await;
+
+  check_alive_then_kill(child);
+}
+
+/// When using `--watch=.`, excluded subdirectories should not trigger restarts
+/// for any file changes within them.
+#[test(flaky)]
+async fn run_watch_directory_with_excluded_subdirectory() {
+  let t = TempDir::new();
+
+  let file_to_watch = t.path().join("main.js");
+  file_to_watch.write("console.log('start');");
+
+  let sub_dir = t.path().join("ignored_dir");
+  sub_dir.create_dir_all();
+  let sub_file = sub_dir.join("data.txt");
+  sub_file.write("data");
+
+  let mut child = util::deno_cmd()
+    .current_dir(t.path())
+    .arg("run")
+    .arg("--watch=.")
+    .arg("--watch-exclude=ignored_dir")
+    .arg("-L")
+    .arg("debug")
+    .arg(&file_to_watch)
+    .env("NO_COLOR", "1")
+    .piped_output()
+    .spawn()
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
+
+  wait_contains("start", &mut stdout_lines).await;
+  wait_contains("finished", &mut stderr_lines).await;
+
+  // Modify file inside excluded subdirectory - should NOT trigger restart
+  sub_file.write("data updated");
+
+  // Modify watched file - should trigger restart
+  file_to_watch.write("console.log('restarted');");
+  wait_contains("Restarting", &mut stderr_lines).await;
+  wait_contains("restarted", &mut stdout_lines).await;
+
+  check_alive_then_kill(child);
+}
+
 #[test(flaky)]
 async fn run_hmr_server() {
   let t = TempDir::new();