Close remaining rewatch build.lock gaps (#8410)

* Close remaining rewatch build.lock gaps

* CHANGELOG
# Conflicts:
#	CHANGELOG.md
#	rewatch/src/build.rs
#	rewatch/src/watcher.rs

Author: cknitt

CHANGELOG.md

@@ -31,6 +31,7 @@
 - Fix type lowering for `dict{}` and `async`, so you don't need to annotate one extra time when the type is known. https://github.com/rescript-lang/rescript/pull/8359
 - Fix issue where warning 56 would blow up with `dict{}` patterns. https://github.com/rescript-lang/rescript/pull/8403
 - Acquire rewatch build lock before initialization. https://github.com/rescript-lang/rescript/pull/8409
+- Close remaining rewatch build.lock gaps. https://github.com/rescript-lang/rescript/pull/8410
 
 #### :nail_care: Polish
 

rewatch/src/build.rs

@@ -236,7 +236,7 @@ impl fmt::Display for IncrementalBuildError {
     }
 }
 
-fn with_build_lock<T>(path: &Path, f: impl FnOnce() -> T) -> T {
+pub fn with_build_lock<T>(path: &Path, f: impl FnOnce() -> T) -> T {
     let build_folder = path.to_string_lossy().to_string();
     let _lock = get_lock_or_exit(LockKind::Build, &build_folder);
     let result = f();
@@ -269,7 +269,7 @@ pub fn incremental_build(
 
 // `build` needs to lock before initialization because initialization mutates previous
 // build artifacts. Keep the compile body separate so it can run under that wider lock.
-fn incremental_build_without_lock(
+pub fn incremental_build_without_lock(
     build_state: &mut BuildCommandState,
     default_timing: Option<Duration>,
     initial_build: bool,

rewatch/src/watcher.rs

@@ -225,7 +225,7 @@ async fn async_watch(
             if show_progress {
                 println!("\nExiting...");
             }
-            clean::cleanup_after_build(&build_state);
+            build::with_build_lock(path, || clean::cleanup_after_build(&build_state));
             break Ok(());
         }
         let mut events: Vec<Event> = vec![];
@@ -250,7 +250,7 @@ async fn async_watch(
                 if show_progress {
                     println!("\nExiting... (lockfile removed)");
                 }
-                clean::cleanup_after_build(&build_state);
+                build::with_build_lock(path, || clean::cleanup_after_build(&build_state));
                 return Ok(());
             }
 
@@ -412,53 +412,59 @@ async fn async_watch(
             }
             CompileType::Full => {
                 let timing_total = Instant::now();
-                let mut next_build_state = build::initialize_build(
-                    None,
-                    filter,
-                    show_progress,
-                    path,
-                    plain_output,
-                    build_state.get_warn_error_override(),
-                )
-                .expect("Could not initialize build");
-
-                // Full rebuilds can be triggered by editor atomic saves that surface as rename events.
-                // Preserve warning state for unchanged modules so their warnings are re-emitted after the
-                // fresh build state replaces the previous one.
-                carry_forward_compile_warnings(&build_state, &mut next_build_state);
-                build_state = next_build_state;
-
-                // 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,
-                    initial_build,
-                    show_progress,
-                    false,
-                    create_sourcedirs,
-                    plain_output,
-                );
-                if let Some(a) = after_build.clone() {
-                    cmd::run(a)
-                }
-
-                build::write_build_ninja(&build_state);
+                // Reinitialization runs cleanup for previous build artifacts, so full rebuilds need
+                // the same build lock boundary as regular `rescript build`.
+                let result = build::with_build_lock(path, || {
+                    let mut next_build_state = build::initialize_build(
+                        None,
+                        filter,
+                        show_progress,
+                        path,
+                        plain_output,
+                        build_state.get_warn_error_override(),
+                    )
+                    .expect("Could not initialize build");
+
+                    // Full rebuilds can be triggered by editor atomic saves that surface as rename events.
+                    // Preserve warning state for unchanged modules so their warnings are re-emitted after the
+                    // fresh build state replaces the previous one.
+                    carry_forward_compile_warnings(&build_state, &mut next_build_state);
+                    build_state = next_build_state;
+
+                    // 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 result = build::incremental_build_without_lock(
+                        &mut build_state,
+                        None,
+                        initial_build,
+                        show_progress,
+                        false,
+                        create_sourcedirs,
+                        plain_output,
+                    );
+                    build::write_build_ninja(&build_state);
+                    result
+                });
+                if result.is_ok() {
+                    if let Some(a) = after_build.clone() {
+                        cmd::run(a)
+                    }
 
-                let timing_total_elapsed = timing_total.elapsed();
-                if show_progress {
-                    if plain_output {
-                        println!("Finished compilation")
-                    } else {
-                        println!(
-                            "\n{}{}Finished compilation in {:.2}s\n",
-                            LINE_CLEAR,
-                            SPARKLES,
-                            timing_total_elapsed.as_secs_f64()
-                        );
+                    let timing_total_elapsed = timing_total.elapsed();
+                    if show_progress {
+                        if plain_output {
+                            println!("Finished compilation")
+                        } else {
+                            println!(
+                                "\n{}{}Finished compilation in {:.2}s\n",
+                                LINE_CLEAR,
+                                SPARKLES,
+                                timing_total_elapsed.as_secs_f64()
+                            );
+                        }
                     }
                 }
                 needs_compile_type = CompileType::None;
@@ -493,16 +499,19 @@ pub fn start(
 
         let path = Path::new(folder);
 
-        // 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")?;
+        // Do an initial build to discover packages and source folders. Initialization can clean
+        // previous build artifacts, so it has to be serialized with other build operations.
+        let build_state: BuildCommandState = build::with_build_lock(path, || {
+            build::initialize_build(
+                None,
+                filter,
+                show_progress,
+                path,
+                plain_output,
+                warn_error.clone(),
+            )
+            .with_context(|| "Could not initialize build")
+        })?;
 
         // Compute and register targeted watches based on source folders
         let current_watch_paths = compute_watch_paths(&build_state, path);