fixup! Rewatch: replace wave scheduler with DAG + critical-path priority (#8374)

Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

rewatch/src/build/compile.rs

@@ -305,6 +305,33 @@ pub fn compile(
         })
         .collect();
 
+    let mut compile_waves = AHashMap::<String, usize>::new();
+    let mut unresolved_waves = compile_universe.clone();
+    while !unresolved_waves.is_empty() {
+        let mut progressed = false;
+        for name in unresolved_waves.iter().cloned().collect::<Vec<String>>() {
+            let module = build_state.get_module(&name).unwrap();
+            let deps = module
+                .deps
+                .iter()
+                .filter(|dep| compile_universe.contains(*dep))
+                .collect::<Vec<&String>>();
+            if deps.iter().all(|dep| compile_waves.contains_key(*dep)) {
+                let wave = deps
+                    .iter()
+                    .filter_map(|dep| compile_waves.get(*dep))
+                    .max()
+                    .map_or(0, |wave| wave + 1);
+                compile_waves.insert(name.clone(), wave);
+                unresolved_waves.remove(&name);
+                progressed = true;
+            }
+        }
+        if !progressed {
+            break;
+        }
+    }
+
     let mut ready_heap: BinaryHeap<WorkUnit> = compile_universe
         .iter()
         .filter(|name| pending_deps[*name] == 0)
@@ -413,6 +440,7 @@ pub fn compile(
     let mut compile_errors = String::new();
     let mut compile_warnings = String::new();
     let mut num_compiled_modules = 0;
+    let mut first_error_wave: Option<usize> = None;
 
     // Persist propagated dirtiness back onto build_state. Modules that were
     // marked dirty (because a predecessor's cmi changed) but never scheduled
@@ -533,6 +561,11 @@ pub fn compile(
             (compile_warning, compile_error, interface_warning, interface_error)
         };
 
+        if compile_error.is_some() || interface_error.is_some() {
+            let wave = compile_waves.get(&module_name).copied().unwrap_or(usize::MAX);
+            first_error_wave = Some(first_error_wave.map_or(wave, |first_wave| first_wave.min(wave)));
+        }
+
         if let Some(warning) = compile_warning {
             logs::append(package, &warning);
             compile_warnings.push_str(&warning);
@@ -606,7 +639,25 @@ pub fn compile(
         }
     }
 
-    Ok((compile_errors, compile_warnings, num_compiled_modules))
+    let reported_num_compiled_modules = if let Some(first_error_wave) = first_error_wave {
+        dirty_set
+            .iter()
+            .filter(|module_name| {
+                compile_waves
+                    .get(*module_name)
+                    .is_some_and(|wave| *wave <= first_error_wave)
+            })
+            .filter(|module_name| {
+                build_state
+                    .get_module(module_name)
+                    .is_some_and(|module| matches!(module.source_type, SourceType::SourceFile(_)))
+            })
+            .count()
+    } else {
+        num_compiled_modules
+    };
+
+    Ok((compile_errors, compile_warnings, reported_num_compiled_modules))
 }
 
 static RUNTIME_PATH_MEMO: OnceLock<PathBuf> = OnceLock::new();