feat: preserve Built stage and FullCompile intent across project

rebuilds

Extract FileBuiltState struct from CompilationStage::Built for reuse in
hash-based promotion snapshots. When project_build reinitializes state,
compare source/AST/CMI/CMT hashes (including interface hashes) to
promote
unchanged modules directly back to Built without recompilation.

For modules whose hashes changed or that were at
CompileError(FullCompile),
persist intent in a full_compile_intent set on PendingState, drained as
step 4 inside build_batch on subsequent flushes with file saves.

Filter errored files from post-build recheck to prevent buffer
typechecks
from overwriting compile error diagnostics. Extract record_error_count
helper shared across file_build and project_build.

Author: nojaf

LSP.md

@@ -81,9 +81,9 @@ rewatch/src/
     ├── notifications.rs         # Custom rescript/buildFinished notification
     ├── queue.rs                 # Unified debounced queue: types, public API, consumer, merge, flush orchestration
     ├── queue/
-    │   ├── file_build.rs        # Per-file incremental build (dependency + dependent closure)
+    │   ├── file_build.rs        # Per-file incremental build (dependency + dependent closure + intent drain)
     │   ├── file_typecheck.rs    # Per-file typecheck (parallel, wave-based, staleness-aware)
-    │   └── project_build.rs     # Per-project full rebuild + artifact cleanup on file creation/deletion
+    │   └── project_build.rs     # Per-project full rebuild + artifact cleanup + hash-based Built promotion
     ├── references.rs            # Find references via analysis binary subprocess
     ├── rename.rs                # Rename via analysis binary subprocess
     ├── semantic_tokens.rs       # Semantic tokens via analysis binary subprocess
@@ -252,21 +252,23 @@ All file events flow into a single unified queue (`lsp/queue.rs`). The queue acc
 - **FileCreated / FileDeleted** (from `didChangeWatchedFiles` Created/Deleted) — structural change requiring full project rebuild
 - **ConfigChanged** (from `didSave` / `didChangeWatchedFiles` for `rescript.json`) — config change requiring full project rebuild
 
-A single background consumer task collects events into a `PendingState` with three action-oriented fields:
+A single background consumer task collects events into a `PendingState` with these fields:
 
 - `typechecks` — files needing typecheck (unsaved buffer content)
 - `compile_files` — files needing incremental build (saved to disk)
 - `build_projects` — a `PendingProjectBuilds` struct containing:
   - `created_files` — file paths whose creation requires a full project rebuild
   - `deleted_files` — file paths whose deletion requires a full project rebuild
   - `config_changed` — `rescript.json` paths requiring full project re-initialization
+- `full_compile_intent` — module names (keyed by project root) that need `FullCompile` (JS emission) but couldn't be compiled yet. Populated by project rebuilds when hash-based promotion fails; drained by incremental builds when modules reach `TypeChecked`
+- `recently_deleted` — file paths deleted in the previous flush, used for cross-flush delete+create detection
 
 The merge function applies promotion rules to consolidate per-file state. When a `FileCreated` or `FileDeleted` event arrives, any pending per-file typecheck or build for that same file is removed since the full rebuild will cover it. A `ConfigChanged` event clears pending typechecks for the same project (since the rebuild will produce fresh type information) but keeps pending compile_files. After 100ms of silence the batch is flushed sequentially:
 
-1. **Full builds first** — re-initialize affected projects from scratch (same flow as the initial build), replacing the old `BuildCommandState`. Clears stale diagnostics for files that no longer exist.
-2. **Incremental builds second** — saved files get a full incremental build (compile dependencies + typecheck dependents). Uses a take-build-replace pattern: each project's `BuildCommandState` is removed from the `ProjectMap` under a brief lock, built without holding the mutex, then inserted back. This keeps LSP handlers (hover, completions, etc.) unblocked during compilation.
+1. **Full builds first** — re-initialize affected projects from scratch (same flow as the initial build), replacing the old `BuildCommandState`. Before replacing the state, snapshots `Built` modules (as `FileBuiltState`) and `CompileError(FullCompile)` module names. After the new state is created, applies hash-based promotion: modules whose implementation/interface/cmi/cmt hashes match the snapshot are promoted directly back to `Built` (no bsc invocation needed). Modules that can't be promoted are added to `full_compile_intent` for deferred JS emission. Clears stale diagnostics for files that no longer exist.
+2. **Incremental builds second** — saved files get a full incremental build (compile dependencies + typecheck dependents + compile resolved errors + drain intent). Uses a take-build-replace pattern: each project's `BuildCommandState` is removed from the `ProjectMap` under a brief lock, built without holding the mutex, then inserted back. This keeps LSP handlers (hover, completions, etc.) unblocked during compilation. Also drains `full_compile_intent` as step 4: modules already compiled in steps 1–3 are skipped (already at `Built`), remaining `TypeChecked` modules get `FullCompile`, and modules not yet ready (e.g. still at `CompileError`) are kept for future flushes.
 3. **Typechecks third** — unsaved edits get a lightweight typecheck via `bsc -bs-read-stdin`, with brief lock for arg extraction only.
-4. **Post-build recheck** — if a saved file also had unsaved buffer content (didChange + didSave in the same debounce window), a typecheck pass runs from the buffer so diagnostics match the editor.
+4. **Post-build recheck** — if a saved file also had unsaved buffer content (didChange + didSave in the same debounce window), a typecheck pass runs from the buffer so diagnostics match the editor. Files whose build produced errors are skipped to avoid overwriting compile error diagnostics with clean buffer typecheck results.
 5. **`buildFinished` notification** — sent when full builds or incremental builds ran.
 
 Sequential execution within one consumer eliminates all races on `lib/lsp/` artifacts.
@@ -365,15 +367,19 @@ didSave / didChangeWatchedFiles notification
           Step 1: Full builds (per project root)
           ├── Group build_projects paths by project root (resolved at flush time)
           ├── Clean up associated files for deleted .res files (.resi + compiled JS)
-          ├── Re-initialize project (re-read packages, re-scan sources)
-          ├── Replace old BuildCommandState
-          ├── Invalidate uri_cache entries
+          ├── Snapshot Built modules (as FileBuiltState) and CompileError(FullCompile) names
+          ├── Re-initialize project (re-read packages, re-scan sources, TypecheckOnly)
+          ├── Hash-based promotion: compare old Built hashes against new TypeChecked hashes
+          │   ├── Match → promote directly to Built (no bsc needed)
+          │   └── Mismatch → add to full_compile_intent for deferred JS emission
+          ├── CompileError(FullCompile) modules → add to full_compile_intent unconditionally
+          ├── Replace old BuildCommandState, invalidate uri_cache entries
           ├── Publish diagnostics from new build
           └── Clear diagnostics for files that no longer exist (old/new URI diff)
                     │
                     ▼
           Step 2: Incremental builds (per project)
-          ├── group files by project root
+          ├── group files by project root (also include projects with pending intents)
           ├── mark_file_parse_dirty per file
           ├── Step 2a: compile_dependencies
           │   ├── parse_and_resolve (parse dirty files, resolve deps)
@@ -386,10 +392,15 @@ didSave / didChangeWatchedFiles notification
           │   ├── Snapshot modules at CompileError(FullCompile) before step 2b
           │   ├── After step 2b, find modules now at TypeChecked (error resolved)
           │   └── FullCompile build for those modules (produces missing JS)
+          ├── Step 2d: drain_full_compile_intent
+          │   ├── Skip modules already at Built (handled by steps 2a–2c or hash promotion)
+          │   ├── FullCompile modules at TypeChecked (produces JS)
+          │   └── Keep modules not yet ready (e.g. CompileError) for future flushes
           └── Publish combined diagnostics from all phases
                     │
                     ▼
           Post-build recheck (if any Build file had stashed buffer content)
+          ├── Skip files whose build produced errors (preserve compile error diagnostics)
                     │
                     ▼
           Send rescript/buildFinished notification
@@ -645,10 +656,16 @@ Parsed       { source_hash, ast_hash, interface_source_hash?, interface_ast_hash
 CompileError { ...same hashes as Parsed..., compile_mode }
 DependencyDirty { ...same hashes as Parsed... }   — dep changed, skip reparse
 TypeChecked  { ...Parsed hashes + cmi_hash, cmt_hash, compiled_at }
-Built        { ...TypeChecked hashes + cmj_hash }
+Built(FileBuiltState)  { ...TypeChecked hashes + cmj_hash }
 ```
 
-Each stage from `Parsed` onward also carries optional parse/compile warnings and optional interface hashes. This data model enables several optimizations that are not yet implemented:
+Each stage from `Parsed` onward also carries optional parse/compile warnings and optional interface hashes. `Built` wraps a `FileBuiltState` struct that is also used for snapshots during hash-based promotion across project rebuilds.
+
+**Already implemented:**
+
+- **Hash-based promotion across project rebuilds**: When `project_build` reinitializes a project (e.g. due to atomic file writes from LLMs or git), it snapshots `FileBuiltState` for all `Built` modules before replacing the state. After the new `TypecheckOnly` build, modules whose implementation/interface/cmi/cmt hashes match the snapshot are promoted directly back to `Built` — no bsc invocation needed. Modules that can't be promoted (hash mismatch or were at `CompileError(FullCompile)`) are added to `full_compile_intent` for deferred JS emission on subsequent flushes.
+
+**Not yet implemented:**
 
 - **No-op save detection**: Compare the on-disk `source_hash` against the hash stored in the module's stage. If they match, the file hasn't actually changed (e.g., user hit save without editing). Parsing and compilation can be skipped entirely.
 - **CMI-based skip in `TypecheckDependents`**: After compiling a saved file, compare its new `cmi_hash` against the pre-save value from the stage. If the interface is unchanged, no dependents need re-typechecking — saving an entire typecheck pass over the dependent closure.

rewatch/src/build/build_types.rs

@@ -82,19 +82,25 @@ pub enum CompilationStage {
     },
     /// Fully compiled (.cmi/.cmt/.cmj + JS produced).
     /// Accumulates all prior hashes + build artifact hashes.
-    Built {
-        implementation_source_hash: Hash,
-        implementation_ast_hash: Hash,
-        interface_source_hash: Option<Hash>,
-        interface_ast_hash: Option<Hash>,
-        cmi_hash: Hash,
-        cmt_hash: Hash,
-        cmj_hash: Hash,
-        compiled_at: SystemTime,
-        implementation_parse_warnings: Option<String>,
-        interface_parse_warnings: Option<String>,
-        compile_warnings: Option<String>,
-    },
+    Built(FileBuiltState),
+}
+
+/// All hashes and metadata for a fully compiled module.
+/// Used both in `CompilationStage::Built` and for snapshots when
+/// preserving Built status across project rebuilds.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileBuiltState {
+    pub implementation_source_hash: Hash,
+    pub implementation_ast_hash: Hash,
+    pub interface_source_hash: Option<Hash>,
+    pub interface_ast_hash: Option<Hash>,
+    pub cmi_hash: Hash,
+    pub cmt_hash: Hash,
+    pub cmj_hash: Hash,
+    pub compiled_at: SystemTime,
+    pub implementation_parse_warnings: Option<String>,
+    pub interface_parse_warnings: Option<String>,
+    pub compile_warnings: Option<String>,
 }
 
 impl CompilationStage {
@@ -131,11 +137,8 @@ impl CompilationStage {
             | CompilationStage::TypeChecked {
                 implementation_parse_warnings,
                 ..
-            }
-            | CompilationStage::Built {
-                implementation_parse_warnings,
-                ..
             } => implementation_parse_warnings.as_deref(),
+            CompilationStage::Built(b) => b.implementation_parse_warnings.as_deref(),
             _ => None,
         }
     }
@@ -158,29 +161,26 @@ impl CompilationStage {
             | CompilationStage::TypeChecked {
                 interface_parse_warnings,
                 ..
-            }
-            | CompilationStage::Built {
-                interface_parse_warnings,
-                ..
             } => interface_parse_warnings.as_deref(),
+            CompilationStage::Built(b) => b.interface_parse_warnings.as_deref(),
             _ => None,
         }
     }
 
     /// Whether compilation produced warnings.
     pub fn has_compile_warnings(&self) -> bool {
         match self {
-            CompilationStage::TypeChecked { compile_warnings, .. }
-            | CompilationStage::Built { compile_warnings, .. } => compile_warnings.is_some(),
+            CompilationStage::TypeChecked { compile_warnings, .. } => compile_warnings.is_some(),
+            CompilationStage::Built(b) => b.compile_warnings.is_some(),
             _ => false,
         }
     }
 
     /// The compile warning text, if any.
     pub fn compile_warnings(&self) -> Option<&str> {
         match self {
-            CompilationStage::TypeChecked { compile_warnings, .. }
-            | CompilationStage::Built { compile_warnings, .. } => compile_warnings.as_deref(),
+            CompilationStage::TypeChecked { compile_warnings, .. } => compile_warnings.as_deref(),
+            CompilationStage::Built(b) => b.compile_warnings.as_deref(),
             _ => None,
         }
     }
@@ -235,15 +235,15 @@ impl CompilationStage {
             | (TypeChecked { .. }, TypeChecked { .. })
             // TypeChecked → Built: compile.rs — FullCompile after TypecheckOnly
             //                      clean.rs — restoring from artifacts
-            | (TypeChecked { .. }, Built { .. })
+            | (TypeChecked { .. }, Built(..))
             // TypeChecked → DependencyDirty: compile.rs — dependency interface changed
             | (TypeChecked { .. }, DependencyDirty { .. })
             // Built → CompileError: compile.rs — LSP save recompile, dependency broke it
-            | (Built { .. }, CompileError { .. })
+            | (Built(..), CompileError { .. })
             // Built → TypeChecked: compile.rs — LSP save recompile in TypecheckOnly mode
-            | (Built { .. }, TypeChecked { .. })
+            | (Built(..), TypeChecked { .. })
             // Built → DependencyDirty: compile.rs — dependency interface changed
-            | (Built { .. }, DependencyDirty { .. })
+            | (Built(..), DependencyDirty { .. })
         )
     }
 
@@ -253,7 +253,7 @@ impl CompilationStage {
     /// (it needs parsing first), but is kept for safety.
     pub fn needs_compile_for_mode(&self, mode: CompileMode) -> bool {
         match (self, mode) {
-            (CompilationStage::Built { .. }, _) => false,
+            (CompilationStage::Built(..), _) => false,
             (CompilationStage::ParseError, _) => false,
             (CompilationStage::TypeChecked { .. }, CompileMode::FullCompile) => true,
             (CompilationStage::TypeChecked { .. }, CompileMode::TypecheckOnly) => false,
@@ -272,8 +272,8 @@ impl CompilationStage {
     /// more recently than a dependent, the dependent must be recompiled.
     pub fn compiled_at(&self) -> Option<SystemTime> {
         match self {
-            CompilationStage::TypeChecked { compiled_at, .. }
-            | CompilationStage::Built { compiled_at, .. } => Some(*compiled_at),
+            CompilationStage::TypeChecked { compiled_at, .. } => Some(*compiled_at),
+            CompilationStage::Built(b) => Some(b.compiled_at),
             _ => None,
         }
     }

rewatch/src/build/clean.rs

@@ -323,7 +323,7 @@ pub fn cleanup_previous_build(
                                 compile_warnings: None,
                             });
                             if cmj_exists && let Some(cmj) = cmj_hash {
-                                sf_module.set_compilation_stage(CompilationStage::Built {
+                                sf_module.set_compilation_stage(CompilationStage::Built(FileBuiltState {
                                     implementation_source_hash: ish,
                                     implementation_ast_hash: iah,
                                     interface_source_hash,
@@ -335,7 +335,7 @@ pub fn cleanup_previous_build(
                                     implementation_parse_warnings: None,
                                     interface_parse_warnings: None,
                                     compile_warnings: None,
-                                });
+                                }));
                             }
                         }
                     }