fix: emit JS for skipped modules when dependency error resolves

nojaf · nojaf · commit 041c1be5241f · 2026-02-23T16:52:22.000+01:00
When a dependency has a compile error, process_in_waves breaks early
and downstream modules in the closure are never attempted by bsc.
These "skipped" modules were left at TypeChecked with no JS output.

Track skipped modules (closure minus compiled) through ProcessResult
and IncrementalBuildError, then register them as FullCompile intent
in build_batch so they get compiled once the dependency is fixed.

Box both `modules` and `skipped_modules` in IncrementalBuildError to
stay under clippy's result_large_err size threshold.
diff --git a/rewatch/src/build.rs b/rewatch/src/build.rs
@@ -266,7 +266,8 @@ pub fn parse_and_resolve(
                 kind: IncrementalBuildErrorKind::SourceFileParseError,
                 output_mode: build_config.output_mode.clone(),
                 diagnostics: parse_diagnostics,
-                modules: AHashSet::new(),
+                modules: Box::default(),
+                skipped_modules: Box::default(),
             });
         }
     };
diff --git a/rewatch/src/build/build_types.rs b/rewatch/src/build/build_types.rs
@@ -425,6 +425,10 @@ pub struct ProcessResult {
     pub compile_errors: String,
     pub compile_warnings: String,
     pub num_compiled_modules: usize,
+    /// Modules that were in the compile universe but never attempted because
+    /// the compile loop broke early (e.g. a dependency error aborted the loop
+    /// before these modules' dependencies were satisfied).
+    pub skipped_modules: AHashSet<String>,
 }
 
 impl ProcessResult {
@@ -869,7 +873,12 @@ pub struct IncrementalBuildError {
     pub kind: IncrementalBuildErrorKind,
     pub diagnostics: Vec<super::diagnostics::BscDiagnostic>,
     /// The set of module names that participated in this compile cycle.
-    pub modules: AHashSet<String>,
+    /// Boxed (along with `skipped_modules`) to keep `IncrementalBuildError`
+    /// under clippy's `result_large_err` size threshold.
+    pub modules: Box<AHashSet<String>>,
+    /// Modules that were in the closure but never attempted by bsc because
+    /// the compile loop broke early due to a dependency error.
+    pub skipped_modules: Box<AHashSet<String>>,
 }
 
 #[derive(Debug, Clone)]
diff --git a/rewatch/src/build/compile.rs b/rewatch/src/build/compile.rs
@@ -800,10 +800,17 @@ pub fn process_in_waves(
         }
     }
 
+    let skipped_modules = compile_params
+        .modules
+        .difference(&compiled_modules)
+        .cloned()
+        .collect();
+
     Ok(ProcessResult {
         compile_errors,
         compile_warnings,
         num_compiled_modules,
+        skipped_modules,
     })
 }
 
diff --git a/rewatch/src/build/compile_dependencies.rs b/rewatch/src/build/compile_dependencies.rs
@@ -39,11 +39,14 @@ pub fn compile_dependencies(
     let result = match compile::process_in_waves(build_state, &params, || {}, |_| {}) {
         Ok(result) => result,
         Err(e) => {
+            // process_in_waves itself failed — the entire closure is skipped.
+            let skipped_modules = Box::new(params.modules.clone());
             return Err(IncrementalBuildError {
                 kind: IncrementalBuildErrorKind::CompileError(Some(e.to_string())),
                 output_mode: OutputMode::Silent,
                 diagnostics: vec![],
-                modules: params.modules,
+                modules: Box::new(params.modules),
+                skipped_modules,
             });
         }
     };
@@ -54,7 +57,8 @@ pub fn compile_dependencies(
             kind: IncrementalBuildErrorKind::CompileError(None),
             output_mode: OutputMode::Silent,
             diagnostics: result.to_diagnostics(),
-            modules: params.modules,
+            modules: Box::new(params.modules),
+            skipped_modules: Box::new(result.skipped_modules),
         })
     } else {
         Ok(IncrementalBuildResult {
diff --git a/rewatch/src/build/full_build.rs b/rewatch/src/build/full_build.rs
@@ -84,7 +84,8 @@ pub fn full_build(
                     kind: IncrementalBuildErrorKind::CompileError(Some(e.to_string())),
                     output_mode: output_mode.clone(),
                     diagnostics: vec![],
-                    modules: params.modules,
+                    modules: Box::new(params.modules),
+                    skipped_modules: Box::default(),
                 });
             }
         };
@@ -128,7 +129,8 @@ pub fn full_build(
             kind: IncrementalBuildErrorKind::CompileError(None),
             output_mode: output_mode.clone(),
             diagnostics: result.to_diagnostics(),
-            modules: params.modules,
+            modules: Box::new(params.modules),
+            skipped_modules: Box::default(),
         })
     } else {
         if show_progress {
diff --git a/rewatch/src/build/full_typecheck.rs b/rewatch/src/build/full_typecheck.rs
@@ -31,7 +31,8 @@ pub fn full_typecheck(
                 kind: IncrementalBuildErrorKind::CompileError(Some(e.to_string())),
                 output_mode: OutputMode::Silent,
                 diagnostics: vec![],
-                modules: params.modules,
+                modules: Box::new(params.modules),
+                skipped_modules: Box::default(),
             });
         }
     };
@@ -42,7 +43,8 @@ pub fn full_typecheck(
             kind: IncrementalBuildErrorKind::CompileError(None),
             output_mode: OutputMode::Silent,
             diagnostics: result.to_diagnostics(),
-            modules: params.modules,
+            modules: Box::new(params.modules),
+            skipped_modules: Box::default(),
         })
     } else {
         write_compiler_info(build_state, OutputTarget::Lsp);
diff --git a/rewatch/src/build/typecheck_dependents.rs b/rewatch/src/build/typecheck_dependents.rs
@@ -50,7 +50,8 @@ pub fn typecheck_dependents(
                 kind: IncrementalBuildErrorKind::CompileError(Some(e.to_string())),
                 output_mode: OutputMode::Silent,
                 diagnostics: vec![],
-                modules: params.modules,
+                modules: Box::new(params.modules),
+                skipped_modules: Box::default(),
             });
         }
     };
@@ -61,7 +62,8 @@ pub fn typecheck_dependents(
             kind: IncrementalBuildErrorKind::CompileError(None),
             output_mode: OutputMode::Silent,
             diagnostics: result.to_diagnostics(),
-            modules: params.modules,
+            modules: Box::new(params.modules),
+            skipped_modules: Box::default(),
         })
     } else {
         Ok(IncrementalBuildResult {
diff --git a/rewatch/src/lsp/queue/file_build.rs b/rewatch/src/lsp/queue/file_build.rs
@@ -237,12 +237,14 @@ fn build_batch(
 ) -> BatchBuildResult {
     let mut diagnostics = Vec::new();
     let mut touched_files = HashSet::new();
+    let mut skipped_modules = HashSet::new();
 
     if !module_names.is_empty() {
         // Steps 1–3: compile saved files, typecheck dependents, resolve errors.
-        let (dep_diags, dep_touched) = compile_dependencies(build_state, &module_names);
-        diagnostics.extend(dep_diags);
-        touched_files.extend(dep_touched);
+        let dep_result = compile_dependencies(build_state, &module_names);
+        diagnostics.extend(dep_result.diagnostics);
+        touched_files.extend(dep_result.touched_files);
+        skipped_modules = dep_result.skipped_modules;
 
         // Snapshot modules at CompileError(FullCompile) before typechecking
         // dependents. These are modules the user saved but that failed to
@@ -281,13 +283,22 @@ fn build_batch(
     }
 
     // Step 4: drain full_compile_intent — compile intent modules that weren't
-    // already handled by steps 1–3. Modules already at Built (compiled as part
-    // of the dependency closure or via hash promotion) are skipped. Modules not
-    // yet at TypeChecked (e.g. still at CompileError) are kept for future flushes.
-    let remaining_intent = if let Some(names) = intent {
-        drain_full_compile_intent(build_state, names, &mut diagnostics, &mut touched_files)
-    } else {
+    // already handled by steps 1–3, plus any modules skipped because step 1
+    // broke early due to a dependency error. Modules already at Built are
+    // skipped. Modules not yet at TypeChecked (e.g. still at CompileError)
+    // are kept for future flushes.
+    let mut intent_names = intent.unwrap_or_default();
+    if !skipped_modules.is_empty() {
+        tracing::debug!(
+            skipped_count = skipped_modules.len(),
+            "build_batch: registering skipped modules as FullCompile intent"
+        );
+        intent_names.extend(skipped_modules);
+    }
+    let remaining_intent = if intent_names.is_empty() {
         HashSet::new()
+    } else {
+        drain_full_compile_intent(build_state, intent_names, &mut diagnostics, &mut touched_files)
     };
 
     record_error_count(&diagnostics);
@@ -305,11 +316,20 @@ fn build_batch(
 /// them, restricting to only the dependency closure.
 /// This produces type information and JavaScript output for just the
 /// saved file and its imports, without touching the rest of the codebase.
+/// Result of the compile_dependencies step.
+struct CompileDependenciesResult {
+    diagnostics: Vec<BscDiagnostic>,
+    touched_files: HashSet<PathBuf>,
+    /// Modules that were in the dependency closure but never attempted by bsc
+    /// because the compile loop broke early (a dependency had errors).
+    skipped_modules: HashSet<String>,
+}
+
 #[instrument(name = "lsp.flush.file_build.compile_dependencies", skip_all, fields(error_count = tracing::field::Empty))]
 fn compile_dependencies(
     build_state: &mut BuildCommandState,
     module_names: &[String],
-) -> (Vec<BscDiagnostic>, HashSet<PathBuf>) {
+) -> CompileDependenciesResult {
     use crate::build::build_types::BuildConfig;
 
     let build_config = BuildConfig {
@@ -333,12 +353,16 @@ fn compile_dependencies(
         Err(e) => {
             // Parse failure — return diagnostics for the affected files, skip compilation
             let touched: HashSet<PathBuf> = e.diagnostics.iter().map(|d| d.file.clone()).collect();
-            return (e.diagnostics, touched);
+            return CompileDependenciesResult {
+                diagnostics: e.diagnostics,
+                touched_files: touched,
+                skipped_modules: HashSet::new(),
+            };
         }
     };
 
     let module_set: AHashSet<String> = module_names.iter().cloned().collect();
-    let (diagnostics, touched_files) =
+    let (diagnostics, touched_files, skipped_modules) =
         match build::compile_dependencies::compile_dependencies(build_state, &module_set) {
             Ok(result) => {
                 tracing::debug!(
@@ -348,19 +372,29 @@ fn compile_dependencies(
                 (
                     result.diagnostics,
                     module_names_to_paths(build_state, &result.modules),
+                    HashSet::new(),
                 )
             }
             Err(e) => {
                 tracing::warn!("Incremental build completed with errors: {e}");
-                (e.diagnostics, module_names_to_paths(build_state, &e.modules))
+                let skipped: HashSet<String> = e.skipped_modules.into_iter().collect();
+                (
+                    e.diagnostics,
+                    module_names_to_paths(build_state, &e.modules),
+                    skipped,
+                )
             }
         };
 
     let mut all_diagnostics = parse_diagnostics;
     all_diagnostics.extend(diagnostics);
     record_error_count(&all_diagnostics);
 
-    (all_diagnostics, touched_files)
+    CompileDependenciesResult {
+        diagnostics: all_diagnostics,
+        touched_files,
+        skipped_modules,
+    }
 }
 
 /// Re-typecheck all modules that import the saved modules (recursively).
diff --git a/tests/rewatch_tests/tests/lsp/__snapshots__/stale-js.test.mjs.snap b/tests/rewatch_tests/tests/lsp/__snapshots__/stale-js.test.mjs.snap
@@ -65,6 +65,94 @@ exports[`lsp stale JS output > does not recompile errored dependents when saving
 ]
 `;
 
+exports[`lsp stale JS output > produces JS for skipped modules when a dependency error is resolved 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[error_count=1]",
+  "        build.parse[dirty_modules=1]",
+  "          build.parse_file[module=Leaf, package=@rewatch-test/dep-chain]",
+  "        compile_dependencies[module_count=4, 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]",
+  "          build.compile_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_save[file=packages/dep-chain/src/App.res]",
+  "  lsp.flush[incremental_builds=packages/dep-chain/src/App.res]",
+  "    lsp.flush.file_build.batch[modules=["App"], error_count=1]",
+  "      lsp.flush.file_build.compile_dependencies[error_count=1]",
+  "        build.parse[dirty_modules=1]",
+  "          build.parse_file[module=App, package=@rewatch-test/dep-chain]",
+  "        compile_dependencies[module_count=4, output=lsp]",
+  "          build.compile",
+  "            build.compile_wave[file_count=2]",
+  "              build.compile_file[module=Button, package=@rewatch-test/dep-chain, suffix=.mjs, module_system=esmodule]",
+  "              build.compile_file[module=Leaf, package=@rewatch-test/dep-chain, suffix=.mjs, module_system=esmodule]",
+  "          build.compile_error",
+  "      lsp.flush.file_build.typecheck_dependents[dependent_count=1]",
+  "        typecheck_dependents[module_count=4, output=lsp]",
+  "          build.typecheck",
+  "            build.typecheck_wave[file_count=1]",
+  "              build.typecheck_file[module=Main, package=@rewatch-test/dep-chain]",
+  "      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=4, 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=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",
+  "      compile_dependencies[module_count=4, output=lsp]",
+  "        build.compile",
+  "          build.compile_wave[file_count=2]",
+  "          build.compile_wave[file_count=1]",
+  "            build.compile_file[module=App, package=@rewatch-test/dep-chain, suffix=.mjs, module_system=esmodule]",
+]
+`;
+
 exports[`lsp stale JS output > regenerates JS for dependents when a dependency fix resolves their errors 1`] = `
 [
   "rewatch.lsp",
diff --git a/tests/rewatch_tests/tests/lsp/stale-js.test.mjs b/tests/rewatch_tests/tests/lsp/stale-js.test.mjs

Original file line number	Diff line number	Diff line change
`@@ -800,10 +800,17 @@ pub fn process_in_waves(`
`800`	`800`	`}`
`801`	`801`	`}`
`802`	`802`
	`803`	`+ let skipped_modules = compile_params`
	`804`	`+ .modules`
	`805`	`+ .difference(&compiled_modules)`
	`806`	`+ .cloned()`
	`807`	`+ .collect();`
	`808`	`+`
`803`	`809`	`Ok(ProcessResult {`
`804`	`810`	`compile_errors,`
`805`	`811`	`compile_warnings,`
`806`	`812`	`num_compiled_modules,`
	`813`	`+ skipped_modules,`
`807`	`814`	`})`
`808`	`815`	`}`
`809`	`816`