fix: preserve ParseError stage in mark_modules_with_expired_deps

mark_modules_with_expired_deps_for_recompile was downgrading ParseError
modules to SourceDirty, allowing them to enter the compile universe with
a stale AST from a previous successful build. When bsc compiled the
module using this stale AST it "succeeded", then the post-loop code
attempted the invalid transition SourceDirty → TypeChecked, which
panicked via debug_assert in set_compilation_stage. Inside
spawn_blocking, this panic prevented BuildCommandState from being
re-inserted into ProjectMap.states, permanently losing the project.

The fix adds a ParseError guard alongside the existing CompileError and
Parsed guards. Also adds a Skipped variant to CompileFileOutcome so
modules not sent to bsc are never added to successfully_compiled.

Author: nojaf

rewatch/src/build/build_types.rs

@@ -525,6 +525,12 @@ impl SourceFileModule {
     ///
     /// Panics in debug builds if the transition is invalid (see
     /// [`CompilationStage::can_transition_to`]).
+    ///
+    /// **WARNING**: In the LSP, `file_build` uses a take-remove-reinsert
+    /// pattern for `BuildCommandState`. If this assertion fires inside
+    /// `spawn_blocking`, the panic prevents the state from being
+    /// re-inserted into `ProjectMap.states`, permanently losing the
+    /// project and breaking all subsequent builds for that project.
     pub fn set_compilation_stage(&mut self, new_stage: CompilationStage) {
         debug_assert!(
             self.compilation_stage.can_transition_to(&new_stage),

rewatch/src/build/compile.rs

@@ -30,11 +30,13 @@ enum CompileFileOutcome {
     Warning(String),
     /// Compilation failed.
     Error(String),
+    /// Module was not sent to the compiler (already at target stage with clean deps).
+    Skipped,
 }
 
 impl CompileFileOutcome {
-    fn is_error(&self) -> bool {
-        matches!(self, CompileFileOutcome::Error(_))
+    fn is_success(&self) -> bool {
+        matches!(self, CompileFileOutcome::Success | CompileFileOutcome::Warning(_))
     }
 }
 
@@ -237,8 +239,8 @@ pub fn process_in_waves(
                         // dependencies had unchanged output (.cmi). Skip it.
                         return Some(CompileModuleResult {
                             module_name: module_name.to_string(),
-                            implementation: CompileFileOutcome::Success,
-                            interface: Some(CompileFileOutcome::Success),
+                            implementation: CompileFileOutcome::Skipped,
+                            interface: Some(CompileFileOutcome::Skipped),
                             is_clean_cmi: true,
                             was_compiled: false,
                         });
@@ -401,19 +403,20 @@ pub fn process_in_waves(
                     }
                     Module::SourceFile(_) => match &entry.implementation {
                         CompileFileOutcome::Warning(warning) => (Some(warning.clone()), None),
-                        CompileFileOutcome::Success => (None, None),
+                        CompileFileOutcome::Success | CompileFileOutcome::Skipped => (None, None),
                         CompileFileOutcome::Error(error) => (None, Some(error.clone())),
                     },
                 };
 
                 let (interface_warning, interface_error) = match &entry.interface {
                     Some(CompileFileOutcome::Warning(warning)) => (Some(warning.clone()), None),
-                    Some(CompileFileOutcome::Success) => (None, None),
+                    Some(CompileFileOutcome::Success) | Some(CompileFileOutcome::Skipped) => (None, None),
                     Some(CompileFileOutcome::Error(error)) => (None, Some(error.clone())),
                     None => (None, None),
                 };
 
-                if !entry.implementation.is_error() && entry.interface.as_ref().is_none_or(|r| !r.is_error())
+                if entry.implementation.is_success()
+                    && entry.interface.as_ref().is_none_or(|r| r.is_success())
                 {
                     successfully_compiled.insert(entry.module_name.clone());
                 } else if entry.was_compiled {
@@ -1321,13 +1324,16 @@ pub fn mark_modules_with_expired_deps_for_recompile(build_state: &mut BuildComma
     build_state.modules.iter_mut().for_each(|(module_name, module)| {
         if let Module::SourceFile(sf) = module
             && modules_with_expired_deps.contains(module_name)
-            // Preserve CompileError and Parsed — both already signal "needs
-            // compilation". CompileError carries semantic meaning for the LSP
-            // flow (step 3 in file_build::build_batch uses it to detect
-            // modules that need full compilation after a dependency fix).
-            // Parsed modules were just parsed in this cycle and resetting them
-            // loses their source/AST hashes.
+            // Preserve CompileError, ParseError, and Parsed — all already
+            // signal "needs work". CompileError carries semantic meaning for
+            // the LSP flow (step 3 in file_build::build_batch uses it to
+            // detect modules that need full compilation after a dependency
+            // fix). Parsed modules were just parsed in this cycle and
+            // resetting them loses their source/AST hashes. ParseError
+            // modules need reparsing, not recompilation — downgrading them
+            // to SourceDirty would let them be compiled with a stale AST.
             && !sf.compilation_stage().is_compile_error()
+            && !sf.compilation_stage().is_parse_error()
             && !matches!(sf.compilation_stage(), CompilationStage::Parsed { .. })
         {
             // Extract parse hashes from the current stage when available.

rewatch/src/lsp/queue/file_build.rs

@@ -139,6 +139,8 @@ pub(super) async fn run(
                 guard.uri_cache.retain(|_, r| *r != root);
                 guard.states.insert(root, state);
             }
+        } else {
+            tracing::error!("projects mutex poisoned in build flush phase 3");
         }
 
         (results, remaining_intent)

tests/rewatch_tests/tests/lsp/__snapshots__/parse-error-new-file.test.mjs.snap

@@ -0,0 +1,93 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`lsp parse error + new file creation > preserves ParseError stage when creating a file triggers mark_modules_with_expired_deps 1`] = `
+[
+  "rewatch.lsp",
+  "  lsp.initialized",
+  "    lsp.register_watchers[watcher_count=3]",
+  "      lsp.discover_package[name=@rewatch-test/dep-chain]",
+  "        lsp.source_dir[dir=packages/dep-chain/src, recursive=true]",
+  "  lsp.initial_build[project=@rewatch-test/dep-chain]",
+  "    build.load_package_sources[package=@rewatch-test/dep-chain]",
+  "    packages.parse_packages",
+  "    clean.cleanup_previous_build",
+  "    build.parse[dirty_modules=4]",
+  "      build.parse_file[module=App, package=@rewatch-test/dep-chain]",
+  "      build.parse_file[module=Button, package=@rewatch-test/dep-chain]",
+  "      build.parse_file[module=Leaf, package=@rewatch-test/dep-chain]",
+  "      build.parse_file[module=Main, package=@rewatch-test/dep-chain]",
+  "    full_typecheck[module_count=4, output=lsp]",
+  "      build.typecheck",
+  "        build.typecheck_wave[file_count=2]",
+  "          build.typecheck_file[module=Button, package=@rewatch-test/dep-chain]",
+  "          build.typecheck_file[module=Leaf, package=@rewatch-test/dep-chain]",
+  "        build.typecheck_wave[file_count=1]",
+  "          build.typecheck_file[module=App, package=@rewatch-test/dep-chain]",
+  "        build.typecheck_wave[file_count=1]",
+  "          build.typecheck_file[module=Main, package=@rewatch-test/dep-chain]",
+  "  lsp.did_save[file=packages/dep-chain/src/Leaf.res]",
+  "  lsp.flush[incremental_builds=packages/dep-chain/src/Leaf.res]",
+  "    lsp.flush.file_build.batch[modules=["Leaf"], error_count=1]",
+  "      lsp.flush.file_build.compile_dependencies",
+  "        build.parse[dirty_modules=1]",
+  "          build.parse_file[module=Leaf, package=@rewatch-test/dep-chain]",
+  "        build.parse_error",
+  "      lsp.flush.file_build.typecheck_dependents[dependent_count=2]",
+  "        typecheck_dependents[module_count=4, output=lsp]",
+  "          build.typecheck",
+  "            build.typecheck_wave[file_count=1]",
+  "              build.typecheck_file[module=App, package=@rewatch-test/dep-chain]",
+  "            build.typecheck_wave[file_count=1]",
+  "              build.typecheck_file[module=Main, package=@rewatch-test/dep-chain]",
+  "      lsp.flush.file_build.compile_resolved",
+  "  lsp.did_change_watched_files[file_count=1]",
+  "  lsp.flush[project_builds=created: packages/dep-chain/src/NewModule.res, incremental_builds=packages/dep-chain/src/NewModule.res]",
+  "    lsp.flush.project_build[project=@rewatch-test/dep-chain]",
+  "      build.load_package_sources[package=@rewatch-test/dep-chain]",
+  "      packages.parse_packages",
+  "      clean.cleanup_previous_build",
+  "      build.parse[dirty_modules=2]",
+  "        build.parse_file[module=Leaf, package=@rewatch-test/dep-chain]",
+  "        build.parse_file[module=NewModule, package=@rewatch-test/dep-chain]",
+  "      build.parse_error",
+  "    lsp.flush.file_build.batch[modules=["NewModule"]]",
+  "      lsp.flush.file_build.compile_dependencies",
+  "        build.parse[dirty_modules=1]",
+  "          build.parse_file[module=NewModule, package=@rewatch-test/dep-chain]",
+  "        compile_dependencies[module_count=5, output=lsp]",
+  "          build.compile",
+  "            build.compile_wave[file_count=1]",
+  "            build.compile_wave[file_count=1]",
+  "              build.compile_file[module=NewModule, package=@rewatch-test/dep-chain, suffix=.mjs, module_system=esmodule]",
+  "          build.compile_error",
+  "      lsp.flush.file_build.typecheck_dependents[dependent_count=0]",
+  "        typecheck_dependents[module_count=5, output=lsp]",
+  "          build.typecheck",
+  "            build.typecheck_wave[file_count=0]",
+  "      lsp.flush.file_build.compile_resolved",
+  "  lsp.did_save[file=packages/dep-chain/src/Leaf.res]",
+  "  lsp.flush[incremental_builds=packages/dep-chain/src/Leaf.res]",
+  "    lsp.flush.file_build.batch[modules=["Leaf"]]",
+  "      lsp.flush.file_build.compile_dependencies",
+  "        build.parse[dirty_modules=1]",
+  "          build.parse_file[module=Leaf, package=@rewatch-test/dep-chain]",
+  "        compile_dependencies[module_count=5, output=lsp]",
+  "          build.compile",
+  "            build.compile_wave[file_count=1]",
+  "              build.compile_file[module=Leaf, package=@rewatch-test/dep-chain, suffix=.mjs, module_system=esmodule]",
+  "      lsp.flush.file_build.typecheck_dependents[dependent_count=3]",
+  "        typecheck_dependents[module_count=5, output=lsp]",
+  "          build.typecheck",
+  "            build.typecheck_wave[file_count=2]",
+  "              build.typecheck_file[module=App, package=@rewatch-test/dep-chain]",
+  "              build.typecheck_file[module=NewModule, package=@rewatch-test/dep-chain]",
+  "            build.typecheck_wave[file_count=1]",
+  "              build.typecheck_file[module=Main, package=@rewatch-test/dep-chain]",
+  "      lsp.flush.file_build.compile_resolved[modules=["NewModule"]]",
+  "        compile_dependencies[module_count=5, output=lsp]",
+  "          build.compile",
+  "            build.compile_wave[file_count=1]",
+  "            build.compile_wave[file_count=1]",
+  "              build.compile_file[module=NewModule, package=@rewatch-test/dep-chain, suffix=.mjs, module_system=esmodule]",
+]
+`;

tests/rewatch_tests/tests/lsp/parse-error-new-file.test.mjs

@@ -0,0 +1,49 @@
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { describe, expect, it } from "vitest";
+import { runLspTest } from "../../helpers/test-context.mjs";
+
+describe("lsp parse error + new file creation", { timeout: 60_000 }, () => {
+  it("preserves ParseError stage when creating a file triggers mark_modules_with_expired_deps", () =>
+    runLspTest(
+      async ({ lsp, lspCwd, writeFile }) => {
+        const rootUri = pathToFileURL(lspCwd).href;
+        await lsp.initialize(rootUri);
+        await lsp.waitForNotification("rescript/buildFinished", 30000);
+
+        // Step 1: Break Leaf.res with a syntax error (parse error, not type error).
+        await writeFile("src/Leaf.res", "let value = {\n");
+        await lsp.waitForNotification("rescript/buildFinished", 30000);
+
+        // Leaf.res should have parse error diagnostics
+        let diagnostics = lsp.getDiagnostics();
+        const leafDiag = diagnostics.find(d => d.file === "src/Leaf.res");
+        expect(leafDiag, "Expected diagnostics for Leaf.res").toBeDefined();
+        expect(leafDiag.diagnostics.length).toBeGreaterThan(0);
+
+        // Step 2: Create a new file that depends on Leaf (which has a parse error).
+        const newFilePath = path.join(lspCwd, "src", "NewModule.res");
+        writeFileSync(newFilePath, 'let greeting = "hello " ++ Leaf.value\n');
+        lsp.notifyWatchedFilesChanged([
+          { relativePath: "src/NewModule.res", type: 1 },
+        ]);
+        await lsp.waitForNotification("rescript/buildFinished", 30000);
+
+        // Step 3: Fix Leaf.res
+        await writeFile("src/Leaf.res", 'let value = "fixed"\n');
+        await lsp.waitForNotification("rescript/buildFinished", 30000);
+
+        // Leaf.res diagnostics should be cleared
+        diagnostics = lsp.getDiagnostics();
+        const leafDiagAfter = diagnostics.find(d => d.file === "src/Leaf.res");
+        if (leafDiagAfter) {
+          expect(
+            leafDiagAfter.diagnostics,
+            `Expected no diagnostics for src/Leaf.res after fix, got: ${JSON.stringify(leafDiagAfter.diagnostics)}`,
+          ).toEqual([]);
+        }
+      },
+      { cwd: "packages/dep-chain" },
+    ));
+});