Add more tests and stream blocking errors as well

python · gvanrossum · Jan 9, 2018 · Dec 15, 2017 · Dec 21, 2017 · Dec 21, 2017
commit 76f945fc47193da18240172e41cd3d9fa883a600
diff --git a/mypy/build.py b/mypy/build.py
@@ -25,9 +25,10 @@
 import time
 from os.path import dirname, basename
 import errno
+from functools import wraps
 
 from typing import (AbstractSet, Any, cast, Dict, Iterable, Iterator, List,
-                    Mapping, NamedTuple, Optional, Set, Tuple, Union, Callable)
+                    Mapping, NamedTuple, Optional, Set, Tuple, TypeVar, Union, Callable)
 # Can't use TYPE_CHECKING because it's not in the Python 3.5.1 stdlib
 MYPY = False
 if MYPY:
@@ -127,13 +128,32 @@ def is_source(self, file: MypyFile) -> bool:
 # be updated in place with newly computed cache data.  See dmypy.py.
 SavedCache = Dict[str, Tuple['CacheMeta', MypyFile, Dict[Expression, Type]]]
 
+F = TypeVar('F', bound=Callable[..., Any])
 

8000
+
+def flush_compile_errors(f: F) -> F:
+    """Catch and flush out any messages from a CompileError thrown in build."""
+    @wraps(f)
+    def func(*args, **kwargs):
+        # type: (*Any, **Any) -> Any
+        try:
+            return f(*args, **kwargs)
+        except CompileError as e:
+            serious = not e.use_stdout
+            error_flush = kwargs.get('flush_errors', None)
+            if error_flush:
+                error_flush(e.messages[e.num_already_seen:], serious)
+            raise
+    return cast(F, func)
+
+
+@flush_compile_errors
 def build(sources: List[BuildSource],
           options: Options,
           alt_lib_path: Optional[str] = None,
           bin_dir: Optional[str] = None,
           saved_cache: Optional[SavedCache] = None,
-          flush_errors: Optional[Callable[[List[str]], None]] = None,
+          flush_errors: Optional[Callable[[List[str], bool], None]] = None,
           plugin: Optional[Plugin] = None,
           ) -> BuildResult:
     """Analyze a program.
@@ -539,7 +559,7 @@ def __init__(self, data_dir: str,
                  version_id: str,
                  plugin: Plugin,
                  errors: Errors,
-                 flush_errors: Optional[Callable[[List[str]], None]] = None,
+                 flush_errors: Optional[Callable[[List[str], bool], None]] = None,
                  saved_cache: Optional[SavedCache] = None,
                  ) -> None:
         self.start_time = time.time()
@@ -712,9 +732,9 @@ def add_stats(self, **kwds: Any) -> None:
     def stats_summary(self) -> Mapping[str, object]:
         return self.stats
 
-    def error_flush(self, msgs: List[str]) -> None:
+    def error_flush(self, msgs: List[str], serious: bool=False) -> None:
         if self.flush_errors:
-            self.flush_errors(msgs)
+            self.flush_errors(msgs, serious)
 
 
 def remove_cwd_prefix_from_path(p: str) -> str:

diff --git a/mypy/errors.py b/mypy/errors.py
@@ -428,7 +428,7 @@ def messages(self) -> List[str]:
 
         Use a form suitable for displaying to the user.
         """
-        self.new_messages()
+        self.new_messages()  # Updates formatted_messages as a side effect
         return self.formatted_messages
 
     def targets(self) -> Set[str]:

diff --git a/mypy/main.py b/mypy/main.py
@@ -61,28 +61,23 @@ def main(script_path: Optional[str], args: Optional[List[str]] = None) -> None:
     if args is None:
         args = sys.argv[1:]
     sources, options = process_options(args)
-    serious = False
-    errors = False
 
-    def flush_errors(a: List[str]) -> None:
-        nonlocal errors
-        if a:
-            errors = True
+    def flush_errors(a: List[str], serious: bool) -> None:
         f = sys.stderr if serious else sys.stdout
         try:
             for m in a:
                 f.write(m + '\n')
         except BrokenPipeError:
             pass
 
+    serious = False
     try:
         res = type_check_only(sources, bin_dir, options, flush_errors)
         a = res.errors
     except CompileError as e:
         a = e.messages
         if not e.use_stdout:
             serious = True
-        flush_errors(a[e.num_already_seen:])
     if options.warn_unused_configs and options.unused_configs:
         print("Warning: unused section(s) in %s: %s" %
               (options.config_file,
@@ -91,7 +86,7 @@ def flush_errors(a: List[str]) -> None:
     if options.junit_xml:
         t1 = time.time()
         util.write_junit_xml(t1 - t0, serious, a, options.junit_xml)
-    if errors:
+    if a:
         sys.exit(1)
 
 
@@ -121,7 +116,7 @@ def readlinkabs(link: str) -> str:
 
 def type_check_only(sources: List[BuildSource], bin_dir: Optional[str],
                     options: Options,
-                    flush_errors: Optional[Callable[[List[str]], None]]) -> BuildResult:
+                    flush_errors: Optional[Callable[[List[str], bool], None]]) -> BuildResult:
     # Type-check the program and dependencies.
     return build.build(sources=sources,
                        bin_dir=bin_dir,

diff --git a/mypy/test/testerrorstream.py b/mypy/test/testerrorstream.py
@@ -31,36 +31,42 @@ def test_error_stream(testcase: DataDrivenTestCase) -> None:
     options = Options()
     options.show_traceback = True
 
-    a = []
+    logged_messages: List[str] = []
+    real_messages: List[str] = []
 
-    def flush_errors(msgs: List[str]) -> None:
-        nonlocal a
+    def flush_errors(msgs: List[str], serious: bool, is_real: bool=True) -> None:
         if msgs:
-            a.append('==== Errors flushed ====')
-            a += msgs
+            logged_messages.append('==== Errors flushed ====')
+            logged_messages.extend(msgs)
+        if is_real:
+            real_messages.extend(msgs)
+
     plugin = ChainedPlugin(options, [LoggingPlugin(options, flush_errors), DefaultPlugin(options)])
 
     sources = [BuildSource('main', '__main__', '\n'.join(testcase.input))]
     try:
-        build.build(sources=sources,
-                    options=options,
-                    alt_lib_path=test_temp_dir,
-                    flush_errors=flush_errors,
-                    plugin=plugin)
+        res = build.build(sources=sources,
+                          options=options,
+                          alt_lib_path=test_temp_dir,
+                          flush_errors=flush_errors,
+                          plugin=plugin)
+        reported_messages = res.errors
     except CompileError as e:
-        a.append('==== Blocking error ====')
-        a += e.messages[e.num_already_seen:]
+        reported_messages = e.messages
 
-    assert_string_arrays_equal(testcase.output, a,
+    assert_string_arrays_equal(testcase.output, logged_messages,
                                'Invalid output ({}, line {})'.format(
                                    testcase.file, testcase.line))
+    assert_string_arrays_equal(reported_messages, real_messages,
+                               'Streamed/reported mismatch ({}, line {})'.format(
+                                   testcase.file, testcase.line))
 
 
 # Use a typechecking plugin to allow test cases to emit messages
 # during typechecking. This allows us to verify that error messages
 # from one SCC are printed before later ones are typechecked.
 class LoggingPlugin(Plugin):
-    def __init__(self, options: Options, log: Callable[[List[str]], None]) -> None:
+    def __init__(self, options: Options, log: Callable[[List[str], bool, bool], None]) -> None:
         super().__init__(options)
         self.log = log
 
@@ -72,5 +78,5 @@ def get_function_hook(self, fullname: str) -> Optional[Callable[[FunctionContext
     def hook(self, ctx: FunctionContext) -> Type:
         assert(isinstance(ctx.context, CallExpr) and len(ctx.context.args) > 0 and
                isinstance(ctx.context.args[0], StrExpr))
-        self.log([ctx.context.args[0].value])
+        self.log([ctx.context.args[0].value], False, False)
         return ctx.default_return_type
diff --git a/test-data/unit/errorstream.test b/test-data/unit/errorstream.test
@@ -39,8 +39,34 @@ import b
 [file b.py]
 import a
 break
+1 / ''  # won't get reported, after a blocker
 [out]
 ==== Errors flushed ====
 a.py:1: error: Unsupported operand types for + ("int" and "str")
-==== Blocking error ====
+==== Errors flushed ====
 b.py:2: error: 'break' outside loop
+
+[case testCycles]
+import a
+[file a.py]
+import b
+1 + ''
+def f() -> int:
+    reveal_type(b.x)
+    return b.x
+y = 0 + 0
+[file b.py]
+import a
+def g() -> int:
+    reveal_type(a.y)
+    return a.y
+1 / ''
+x = 1 + 1
+
+[out]
+==== Errors flushed ====
+b.py:3: error: Revealed type is 'builtins.int'
+b.py:5: error: Unsupported operand types for / ("int" and "str")
+==== Errors flushed ====
+a.py:2: error: Unsupported operand types for + ("int" and "str")
+a.py:4: error: Revealed type is 'builtins.int'