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

@@ -265,6 +265,7 @@ pub fn compile(
             }
         })
         .collect::<AHashSet<String>>();
+    let originally_dirty_modules = dirty_modules.clone();
 
     // Expand the compile universe: every dirty module plus everything that
     // transitively depends on it.
@@ -459,7 +460,37 @@ pub fn compile(
     // though modules complete in arbitrary order.
     results_buffer.sort_by(|a, b| a.module_name.cmp(&b.module_name));
 
-    let mut recompiled_modules = AHashSet::<String>::new();
+    let stored_warnings_before_compile = build_state
+        .modules
+        .iter()
+        .filter_map(|(module_name, module)| {
+            if originally_dirty_modules.contains(module_name) {
+                return None;
+            }
+
+            let SourceType::SourceFile(source_file) = &module.source_type else {
+                return None;
+            };
+
+            let implementation_warning = source_file.implementation.compile_warnings.clone();
+            let interface_warning = source_file
+                .interface
+                .as_ref()
+                .and_then(|interface| interface.compile_warnings.clone());
+
+            if implementation_warning.is_none() && interface_warning.is_none() {
+                return None;
+            }
+
+            Some((
+                module_name.clone(),
+                module.package_name.clone(),
+                implementation_warning,
+                interface_warning,
+            ))
+        })
+        .collect::<Vec<(String, String, Option<String>, Option<String>)>>();
+    let mut modules_with_emitted_warnings = AHashSet::<String>::new();
 
     for msg in results_buffer {
         let CompletionMsg {
@@ -472,7 +503,6 @@ pub fn compile(
 
         if is_compiled {
             num_compiled_modules += 1;
-            recompiled_modules.insert(module_name.clone());
         }
 
         let package_name = {
@@ -569,6 +599,7 @@ pub fn compile(
         if let Some(warning) = compile_warning {
             logs::append(package, &warning);
             compile_warnings.push_str(&warning);
+            modules_with_emitted_warnings.insert(module_name.clone());
         }
         if let Some(error) = compile_error {
             logs::append(package, &error);
@@ -577,6 +608,7 @@ pub fn compile(
         if let Some(warning) = interface_warning {
             logs::append(package, &warning);
             compile_warnings.push_str(&warning);
+            modules_with_emitted_warnings.insert(module_name.clone());
         }
         if let Some(error) = interface_error {
             logs::append(package, &error);
@@ -613,29 +645,27 @@ pub fn compile(
         compile_errors.push_str(&message);
     }
 
-    // Collect warnings from modules that were not recompiled in this build but still have stored
-    // warnings from a previous compilation. This includes ready modules that were in the compile
-    // universe but never scheduled because an earlier module failed.
-    for (module_name, module) in build_state.modules.iter() {
-        if recompiled_modules.contains(module_name) {
+    // Collect warnings from modules that did not emit a warning in this build but still had stored
+    // warnings from a previous compilation before we started. This includes ready modules that were
+    // in the compile universe but never scheduled because an earlier module failed.
+    for (module_name, package_name, implementation_warning, interface_warning) in
+        stored_warnings_before_compile
+    {
+        if modules_with_emitted_warnings.contains(&module_name) {
             continue;
         }
-        if let SourceType::SourceFile(ref source_file) = module.source_type {
-            let package = build_state.get_package(&module.package_name);
-            if let Some(ref warning) = source_file.implementation.compile_warnings {
-                if let Some(package) = package {
-                    logs::append(package, warning);
-                }
-                compile_warnings.push_str(warning);
+        let package = build_state.get_package(&package_name);
+        if let Some(warning) = implementation_warning {
+            if let Some(package) = package {
+                logs::append(package, &warning);
             }
-            if let Some(ref interface) = source_file.interface
-                && let Some(ref warning) = interface.compile_warnings
-            {
-                if let Some(package) = package {
-                    logs::append(package, warning);
-                }
-                compile_warnings.push_str(warning);
+            compile_warnings.push_str(&warning);
+        }
+        if let Some(warning) = interface_warning {
+            if let Some(package) = package {
+                logs::append(package, &warning);
             }
+            compile_warnings.push_str(&warning);
         }
     }