Ensure that cache files for modules without errors are written

Author: Guido van Rossum

mypy/build.py

@@ -1516,7 +1516,14 @@ def valid_references(self) -> Set[str]:
         return valid_refs
 
     def write_cache(self) -> None:
-        if self.path and self.options.incremental and not self.manager.errors.is_errors():
+        ok = self.path and self.options.incremental
+        if ok:
+            if self.manager.options.quick_and_dirty:
+                is_errors = self.manager.errors.is_errors_for_file(self.path)
+            else:
+                is_errors = self.manager.errors.is_errors()
+            ok = not is_errors
+        if ok:
             dep_prios = [self.priorities.get(dep, PRI_HIGH) for dep in self.dependencies]
             new_interface_hash = write_cache(
                 self.id, self.path, self.tree,

mypy/errors.py

@@ -76,6 +76,9 @@ class Errors:
     # Current error context: nested import context/stack, as a list of (path, line) pairs.
     import_ctx = None  # type: List[Tuple[str, int]]
 
+    # Set of files with errors.
+    error_files = None  # type: Set[str]
+
     # Path name prefix that is removed from all paths, if set.
     ignore_prefix = None  # type: str
 
@@ -110,6 +113,7 @@ def __init__(self, show_error_context: bool = False,
                  show_column_numbers: bool = False) -> None:
         self.error_info = []
         self.import_ctx = []
+        self.error_files = set()
         self.type_name = [None]
         self.function_or_member = [None]
         self.ignored_lines = OrderedDict()
@@ -230,6 +234,7 @@ def add_error_info(self, info: ErrorInfo) -> None:
                 return
             self.only_once_messages.add(info.message)
         self.error_info.append(info)
+        self.error_files.add(file)
 
     def generate_unused_ignore_notes(self) -> None:
         for file, ignored_lines in self.ignored_lines.items():
@@ -257,6 +262,10 @@ def is_blockers(self) -> bool:
         """Are the any errors that are blockers?"""
         return any(err for err in self.error_info if err.blocker)
 
+    def is_errors_for_file(self, file: str) -> bool:
+        """Are there any errors for the given file?"""
+        return file in self.error_files
+
     def raise_error(self) -> None:
         """Raise a CompileError with the generated messages.
 

test-data/unit/check-incremental.test

@@ -6,6 +6,11 @@
 -- errors expected in the second run should be in the `[out2]` section. If a
 -- section is omitted, it is expected there are no errors on that run.
 --
+-- As always, extra flags may be specified using
+-- # flags: --some-flag
+-- If the second run requires different flags, those can be specified using
+-- # flags2: --another-flag
+--
 -- Any files that we expect to be rechecked should be annotated in the [rechecked]
 -- annotation, and any files expect to be stale (aka have a modified interface)
 -- should be annotated in the [stale] annotation. Note that a file that ends up
@@ -1903,3 +1908,19 @@ import b
 import a
 [rechecked a, b, builtins]
 [stale a, b, builtins]
+
+[case testQuickAndDirty4]
+# flags: --quick-and-dirty
+import a, b
+[file a.py]
+import b
+def foo() -> int: return ''
+[file b.py]
+import a
+[file a.py.next]
+def foo() -> int: return 0
+[out1]
+tmp/a.py:2: error: Incompatible return value type (got "str", expected "int")
+[out2]
+[rechecked a]
+[stale a]