Watch folders based on BuildState (#8219)

nojaf · cknitt · commit 7995ed72e7f2 · 2026-01-27T11:04:46.000+01:00
* Watch folders based on BuildState

* Add additional test cases

* Code review feedback

* Make test cross plat (I hope)

* Avoids sleeps in test

* Log error when source folder does not exist.

* Add changelog entry

* Code review feedback

* Avoid race condition (I hope)

* Trigger CI
# Conflicts:
#	AGENTS.md
#	CHANGELOG.md
#	rewatch/tests/03-watch-new-file.sh
#	rewatch/tests/04-watch-config-change.sh
#	rewatch/tests/05-watch-ignores-non-source.sh
#	rewatch/tests/06-watch-missing-source-folder.sh
#	rewatch/tests/suite.sh
#	rewatch/tests/watch/02-watch-warnings-persist.sh
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -38,6 +38,7 @@
 
 - Formatter no longer writes files when contents are already correctly formatted. https://github.com/rescript-lang/rescript/pull/8209
 - Build system: Only log verbose "Generating AST for module" when actually parsing. https://github.com/rescript-lang/rescript/pull/8210
+- Build system: Watch only source folders from build state instead of the entire project directory, and report missing configured source folders. https://github.com/rescript-lang/rescript/pull/8219
 
 #### :house: Internal
 
diff --git a/rewatch/src/watcher.rs b/rewatch/src/watcher.rs
@@ -1,7 +1,8 @@
 use crate::build;
-use crate::build::build_types::SourceType;
+use crate::build::build_types::{BuildCommandState, SourceType};
 use crate::build::clean;
 use crate::cmd;
+use crate::config;
 use crate::helpers;
 use crate::helpers::StrippedVerbatimPath;
 use crate::helpers::emojis::*;
@@ -12,7 +13,7 @@ use anyhow::{Context, Result};
 use futures_timer::Delay;
 use notify::event::ModifyKind;
 use notify::{Config, Error, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
@@ -57,32 +58,116 @@ fn matches_filter(path_buf: &Path, filter: &Option<regex::Regex>) -> bool {
     filter.as_ref().map(|re| !re.is_match(&name)).unwrap_or(true)
 }
 
+/// Computes the list of paths to watch based on the build state.
+/// Returns tuples of (path, recursive_mode) for each watch target.
+fn compute_watch_paths(build_state: &BuildCommandState, root: &Path) -> Vec<(PathBuf, RecursiveMode)> {
+    // Use a HashMap to deduplicate paths, giving precedence to Recursive mode
+    // when the same path appears with different modes (e.g. package root watched
+    // NonRecursively for rescript.json changes, but also as a source folder with
+    // Recursive mode).
+    let mut watch_paths: std::collections::HashMap<PathBuf, RecursiveMode> = std::collections::HashMap::new();
+
+    let mut insert = |path: PathBuf, mode: RecursiveMode| {
+        watch_paths
+            .entry(path)
+            .and_modify(|existing| {
+                if mode == RecursiveMode::Recursive {
+                    *existing = RecursiveMode::Recursive;
+                }
+            })
+            .or_insert(mode);
+    };
+
+    for (_, package) in build_state.build_state.packages.iter() {
+        if !package.is_local_dep {
+            continue;
+        }
+
+        // Watch the package root non-recursively to detect rescript.json changes.
+        // We watch the directory rather than the file directly because many editors
+        // use atomic writes (delete + recreate or write to temp + rename) which would
+        // cause a direct file watch to be lost after the first edit.
+        insert(package.path.clone(), RecursiveMode::NonRecursive);
+
+        // Watch each source folder
+        for source in &package.source_folders {
+            let dir = package.path.join(&source.dir);
+            if !dir.exists() {
+                log::error!(
+                    "Could not read folder: {:?}. Specified in dependency: {}, located {:?}...",
+                    source.dir,
+                    package.name,
+                    package.path
+                );
+                continue;
+            }
+            let mode = match &source.subdirs {
+                Some(config::Subdirs::Recurse(true)) => RecursiveMode::Recursive,
+                _ => RecursiveMode::NonRecursive,
+            };
+            insert(dir, mode);
+        }
+    }
+
+    // Watch the lib/ directory for the lockfile (rescript.lock lives in lib/)
+    let lib_dir = root.join("lib");
+    if lib_dir.exists() {
+        insert(lib_dir, RecursiveMode::NonRecursive);
+    }
+
+    watch_paths.into_iter().collect()
+}
+
+/// Registers all watch paths with the given watcher.
+fn register_watches(watcher: &mut RecommendedWatcher, watch_paths: &[(PathBuf, RecursiveMode)]) {
+    for (path, mode) in watch_paths {
+        let mode_str = if *mode == RecursiveMode::Recursive {
+            "recursive"
+        } else {
+            "non-recursive"
+        };
+        log::debug!("  watching ({mode_str}): {}", path.display());
+        if let Err(e) = watcher.watch(path, *mode) {
+            log::error!("Could not watch {}: {}", path.display(), e);
+        }
+    }
+}
+
+/// Unregisters all watch paths from the given watcher.
+fn unregister_watches(watcher: &mut RecommendedWatcher, watch_paths: &[(PathBuf, RecursiveMode)]) {
+    for (path, _) in watch_paths {
+        let _ = watcher.unwatch(path);
+    }
+}
+
 struct AsyncWatchArgs<'a> {
+    watcher: &'a mut RecommendedWatcher,
+    current_watch_paths: Vec<(PathBuf, RecursiveMode)>,
+    initial_build_state: BuildCommandState,
     q: Arc<FifoQueue<Result<Event, Error>>>,
     path: &'a Path,
     show_progress: bool,
     filter: &'a Option<regex::Regex>,
     after_build: Option<String>,
     create_sourcedirs: bool,
     plain_output: bool,
-    warn_error: Option<String>,
 }
 
 async fn async_watch(
     AsyncWatchArgs {
+        watcher,
+        mut current_watch_paths,
+        initial_build_state,
         q,
         path,
         show_progress,
         filter,
         after_build,
         create_sourcedirs,
         plain_output,
-        warn_error,
     }: AsyncWatchArgs<'_>,
 ) -> Result<()> {
-    let mut build_state: build::build_types::BuildCommandState =
-        build::initialize_build(None, filter, show_progress, path, plain_output, warn_error)
-            .with_context(|| "Could not initialize build")?;
+    let mut build_state = initial_build_state;
     let mut needs_compile_type = CompileType::Incremental;
     // create a mutex to capture if ctrl-c was pressed
     let ctrlc_pressed = Arc::new(Mutex::new(false));
@@ -128,6 +213,21 @@ async fn async_watch(
                 return Ok(());
             }
 
+            // Detect rescript.json changes and trigger a full rebuild
+            if event
+                .paths
+                .iter()
+                .any(|p| p.file_name().map(|name| name == "rescript.json").unwrap_or(false))
+                && matches!(
+                    event.kind,
+                    EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)
+                )
+            {
+                log::debug!("rescript.json changed -> full compile");
+                needs_compile_type = CompileType::Full;
+                continue;
+            }
+
             let paths = event
                 .paths
                 .iter()
@@ -280,6 +380,12 @@ async fn async_watch(
                     build_state.get_warn_error_override(),
                 )
                 .expect("Could not initialize build");
+
+                // Re-register watches based on the new build state
+                unregister_watches(watcher, &current_watch_paths);
+                current_watch_paths = compute_watch_paths(&build_state, path);
+                register_watches(watcher, &current_watch_paths);
+
                 let _ = build::incremental_build(
                     &mut build_state,
                     None,
@@ -334,23 +440,34 @@ pub fn start(
         let mut watcher = RecommendedWatcher::new(move |res| producer.push(res), Config::default())
             .expect("Could not create watcher");
 
-        log::debug!("watching {folder}");
+        let path = Path::new(folder);
 
-        watcher
-            .watch(Path::new(folder), RecursiveMode::Recursive)
-            .expect("Could not start watcher");
+        // Do an initial build to discover packages and source folders
+        let build_state: BuildCommandState = build::initialize_build(
+            None,
+            filter,
+            show_progress,
+            path,
+            plain_output,
+            warn_error.clone(),
+        )
+        .with_context(|| "Could not initialize build")?;
 
-        let path = Path::new(folder);
+        // Compute and register targeted watches based on source folders
+        let current_watch_paths = compute_watch_paths(&build_state, path);
+        register_watches(&mut watcher, &current_watch_paths);
 
         async_watch(AsyncWatchArgs {
+            watcher: &mut watcher,
+            current_watch_paths,
+            initial_build_state: build_state,
             q: consumer,
             path,
             show_progress,
             filter,
             after_build,
             create_sourcedirs,
             plain_output,
-            warn_error: warn_error.clone(),
         })
         .await
     })
diff --git a/rewatch/tests/lock.sh b/rewatch/tests/lock.sh
@@ -15,11 +15,6 @@ else
   exit 1
 fi
 
-exit_watcher() {
-  # kill watcher by removing lock file
-  rm lib/rescript.lock
-}
-
 rewatch_bg watch > /dev/null 2>&1 &
 success "Watcher Started"
 
diff --git a/rewatch/tests/utils.sh b/rewatch/tests/utils.sh
@@ -50,3 +50,27 @@ replace() {
     sed -i $1 $2;
   fi
 }
+
+exit_watcher() {
+  rm -f lib/rescript.lock
+}
+
+wait_for_file() {
+  local file="$1"; local timeout="${2:-30}"
+  while [ "$timeout" -gt 0 ]; do
+    [ -f "$file" ] && return 0
+    sleep 1
+    timeout=$((timeout - 1))
+  done
+  return 1
+}
+
+wait_for_file_gone() {
+  local file="$1"; local timeout="${2:-30}"
+  while [ "$timeout" -gt 0 ]; do
+    [ ! -f "$file" ] && return 0
+    sleep 1
+    timeout=$((timeout - 1))
+  done
+  return 1
+}
diff --git a/rewatch/tests/watch.sh b/rewatch/tests/watch.sh
@@ -13,22 +13,6 @@ else
   exit 1
 fi
 
-exit_watcher() {
-  # kill watcher by removing lock file
-  rm lib/rescript.lock
-}
-
-# Wait until a file exists (with timeout in seconds, default 30)
-wait_for_file() {
-  local file="$1"; local timeout="${2:-30}"
-  while [ "$timeout" -gt 0 ]; do
-    [ -f "$file" ] && return 0
-    sleep 1
-    timeout=$((timeout - 1))
-  done
-  return 1
-}
-
 # Start watcher and capture logs for debugging
 rewatch_bg watch > rewatch.log 2>&1 &
 success "Watcher Started"
