dont cache modules with errors

Author: roryc89

src/build/cache.rs

@@ -267,6 +267,13 @@ impl ModuleCache {
         exports_changed
     }
 
+    /// Remove a module from the cache (e.g. when it fails typechecking).
+    pub fn remove(&mut self, module_name: &str) {
+        if self.entries.remove(module_name).is_some() {
+            self.index_dirty = true;
+        }
+    }
+
     /// Build the reverse dependency graph from cached import data.
     pub fn build_reverse_deps(&mut self) {
         self.dependents.clear();

src/build/mod.rs

@@ -706,17 +706,26 @@ fn build_from_sources_impl(
                             "  [{}/{}] ok: {} ({:.2?})",
                             done, total_modules, pm.module_name, elapsed
                         );
-                        let import_names: Vec<String> = pm.import_parts.iter()
-                            .map(|parts| interner::resolve_module_name(parts))
-                            .collect();
-                        let exports_changed = if let Some(ref mut c) = cache {
-                            c.update(pm.module_name.clone(), pm.source_hash, result.exports.clone(), import_names)
-                        } else {
-                            true
-                        };
-                        // Only add to rebuilt_set if exports actually changed
-                        if exports_changed {
+                        let has_errors = !result.errors.is_empty();
+                        if has_errors {
+                            // Don't cache modules with type errors
+                            if let Some(ref mut c) = cache {
+                                c.remove(&pm.module_name);
+                            }
                             rebuilt_set.insert(pm.module_name.clone());
+                        } else {
+                            let import_names: Vec<String> = pm.import_parts.iter()
+                                .map(|parts| interner::resolve_module_name(parts))
+                                .collect();
+                            let exports_changed = if let Some(ref mut c) = cache {
+                                c.update(pm.module_name.clone(), pm.source_hash, result.exports.clone(), import_names)
+                            } else {
+                                true
+                            };
+                            // Only add to rebuilt_set if exports actually changed
+                            if exports_changed {
+                                rebuilt_set.insert(pm.module_name.clone());
+                            }
                         }
                         // Register exports immediately — result.exports is moved,
                         // then result (with its types HashMap) is dropped.
@@ -834,16 +843,25 @@ fn build_from_sources_impl(
                             "  [{}/{}] ok: {} ({:.2?})",
                             done, total_modules, pm.module_name, elapsed
                         );
-                        let import_names: Vec<String> = pm.import_parts.iter()
-                            .map(|parts| interner::resolve_module_name(parts))
-                            .collect();
-                        let exports_changed = if let Some(ref mut c) = cache {
-                            c.update(pm.module_name.clone(), pm.source_hash, result.exports.clone(), import_names)
-                        } else {
-                            true
-                        };
-                        if exports_changed {
+                        let has_errors = !result.errors.is_empty();
+                        if has_errors {
+                            // Don't cache modules with type errors
+                            if let Some(ref mut c) = cache {
+                                c.remove(&pm.module_name);
+                            }
                             rebuilt_set.insert(pm.module_name.clone());
+                        } else {
+                            let import_names: Vec<String> = pm.import_parts.iter()
+                                .map(|parts| interner::resolve_module_name(parts))
+                                .collect();
+                            let exports_changed = if let Some(ref mut c) = cache {
+                                c.update(pm.module_name.clone(), pm.source_hash, result.exports.clone(), import_names)
+                            } else {
+                                true
+                            };
+                            if exports_changed {
+                                rebuilt_set.insert(pm.module_name.clone());
+                            }
                         }
                         registry.register(&pm.module_parts, result.exports);
                         module_results.push(ModuleResult {

tests/build.rs

@@ -1320,3 +1320,23 @@ fn incremental_build_disk_roundtrip() {
     // Cleanup
     let _ = std::fs::remove_dir_all(&tmp_dir);
 }
+
+#[test]
+fn incremental_build_does_not_cache_errors() {
+    let sources: Vec<(&str, &str)> = vec![
+        ("ModA.purs", "module ModA where\n\nvalA :: Int\nvalA = undefinedVar\n"),
+    ];
+
+    let options = BuildOptions::default();
+    let mut cache = ModuleCache::new();
+
+    // First build: should report type error (undefinedVar is not defined)
+    let (result1, _, _) = build_from_sources_incremental(&sources, &None, None, &options, &mut cache);
+    let has_type_errors_1 = result1.modules.iter().any(|m| !m.type_errors.is_empty());
+    assert!(has_type_errors_1, "First build should have type errors");
+
+    // Second build with same sources: error should NOT be cached away
+    let (result2, _, _) = build_from_sources_incremental(&sources, &None, None, &options, &mut cache);
+    let has_type_errors_2 = result2.modules.iter().any(|m| !m.type_errors.is_empty());
+    assert!(has_type_errors_2, "Second build should still have type errors (not cached)");
+}