[mypyc] Refactor mypyc error handling (python#7627)

msullivan · web-flow · commit cc7667a2008e · 2019-10-04T13:52:52.000-07:00
Pull Errors out into its own module and have it get managed externally
from genops. This is in preparation for separate/incremental
compilation.
diff --git a/mypyc/build.py b/mypyc/build.py
@@ -35,6 +35,7 @@
 from mypy.build import BuildSource
 from mypyc.namegen import exported_name
 from mypyc.options import CompilerOptions
+from mypyc.errors import Errors
 
 from mypyc import emitmodule
 
@@ -182,9 +183,15 @@ def generate_c(sources: List[BuildSource], options: Options,
     if compiler_options.verbose:
         print("Parsed and typechecked in {:.3f}s".format(t1 - t0))
 
+    errors = Errors()
+
     ops = []  # type: List[str]
     ctext = emitmodule.compile_modules_to_c(result, module_names, shared_lib_name,
-                                            compiler_options=compiler_options, ops=ops)
+                                            compiler_options=compiler_options,
+                                            errors=errors, ops=ops)
+    if errors.num_errors:
+        errors.flush_errors()
+        sys.exit(1)
 
     t2 = time.time()
     if compiler_options.verbose:
diff --git a/mypyc/emitmodule.py b/mypyc/emitmodule.py
@@ -1,7 +1,5 @@
 """Generate C code for a Python C extension module from Python source code."""
 
-import sys
-
 from collections import OrderedDict
 from typing import List, Tuple, Dict, Iterable, Set, TypeVar, Optional
 
@@ -23,6 +21,7 @@
 from mypyc.refcount import insert_ref_count_opcodes
 from mypyc.exceptions import insert_exception_handling
 from mypyc.namegen import exported_name
+from mypyc.errors import Errors
 
 
 class MarkedDeclaration:
@@ -46,15 +45,16 @@ def parse_and_typecheck(sources: List[BuildSource], options: Options,
 def compile_modules_to_c(result: BuildResult, module_names: List[str],
                          shared_lib_name: Optional[str],
                          compiler_options: CompilerOptions,
+                         errors: Errors,
                          ops: Optional[List[str]] = None) -> List[Tuple[str, str]]:
     """Compile Python module(s) to C that can be used from Python C extension modules."""
 
     # Generate basic IR, with missing exception and refcount handling.
     file_nodes = [result.files[name] for name in module_names]
-    literals, modules, errors = genops.build_ir(file_nodes, result.graph, result.types,
-                                                compiler_options)
-    if errors > 0:
-        sys.exit(1)
+    literals, modules = genops.build_ir(file_nodes, result.graph, result.types,
+                                        compiler_options, errors)
+    if errors.num_errors > 0:
+        return []
     # Insert uninit checks.
     for _, module in modules:
         for fn in module.functions:
diff --git a/mypyc/errors.py b/mypyc/errors.py
@@ -0,0 +1,20 @@
+import mypy.errors
+
+
+class Errors:
+    def __init__(self) -> None:
+        self.num_errors = 0
+        self.num_warnings = 0
+        self._errors = mypy.errors.Errors()
+
+    def error(self, msg: str, path: str, line: int) -> None:
+        self._errors.report(line, None, msg, severity='error', file=path)
+        self.num_errors += 1
+
+    def warning(self, msg: str, path: str, line: int) -> None:
+        self._errors.report(line, None, msg, severity='warning', file=path)
+        self.num_warnings += 1
+
+    def flush_errors(self) -> None:
+        for error in self._errors.new_messages():
+            print(error)
diff --git a/mypyc/genops.py b/mypyc/genops.py
@@ -37,8 +37,6 @@ def f(x: int) -> int:
     TypeVarExpr, TypedDictExpr, UnicodeExpr, WithStmt, YieldFromExpr, YieldExpr, GDEF, ARG_POS,
     ARG_OPT, ARG_NAMED, ARG_NAMED_OPT, ARG_STAR, ARG_STAR2, is_class_var, op_methods
 )
-import mypy.nodes
-import mypy.errors
 from mypy.types import (
     Type, Instance, CallableType, NoneTyp, TupleType, UnionType, AnyType, TypeVarType, PartialType,
     TypeType, Overloaded, TypeOfAny, UninhabitedType, UnboundType, TypedDictType,
@@ -99,6 +97,7 @@ def f(x: int) -> int:
 from mypyc.sametype import is_same_type, is_same_method_signature
 from mypyc.crash import catch_errors
 from mypyc.options import CompilerOptions
+from mypyc.errors import Errors
 
 GenFunc = Callable[[], None]
 DictEntry = Tuple[Optional[Value], Value]
@@ -108,25 +107,6 @@ class UnsupportedException(Exception):
     pass
 
 
-class Errors:
-    def __init__(self) -> None:
-        self.num_errors = 0
-        self.num_warnings = 0
-        self._errors = mypy.errors.Errors()
-
-    def error(self, msg: str, path: str, line: int) -> None:
-        self._errors.report(line, None, msg, severity='error', file=path)
-        self.num_errors += 1
-
-    def warning(self, msg: str, path: str, line: int) -> None:
-        self._errors.report(line, None, msg, severity='warning', file=path)
-        self.num_warnings += 1
-
-    def flush_errors(self) -> None:
-        for error in self._errors.new_messages():
-            print(error)
-
-
 # The stubs for callable contextmanagers are busted so cast it to the
 # right type...
 F = TypeVar('F', bound=Callable[..., Any])
@@ -137,10 +117,10 @@ def flush_errors(self) -> None:
 def build_ir(modules: List[MypyFile],
              graph: Graph,
              types: Dict[Expression, Type],
-             options: CompilerOptions) -> Tuple[LiteralsMap, List[Tuple[str, ModuleIR]], int]:
+             options: CompilerOptions,
+             errors: Errors) -> Tuple[LiteralsMap, List[Tuple[str, ModuleIR]]]:
     result = []
     mapper = Mapper()
-    errors = Errors()
 
     # Collect all classes defined in the compilation unit.
     classes = []
@@ -205,9 +185,7 @@ def build_ir(modules: List[MypyFile],
         if cir.is_ext_class:
             compute_vtable(cir)
 
-    errors.flush_errors()
-
-    return mapper.literals, result, errors.num_errors
+    return mapper.literals, result
 
 
 def is_extension_class(cdef: ClassDef) -> bool:
diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
@@ -17,6 +17,7 @@
 
 from mypyc import emitmodule
 from mypyc.options import CompilerOptions
+from mypyc.errors import Errors
 from mypyc.build import shared_lib_name
 from mypyc.test.testutil import (
     ICODE_GEN_BUILTINS, TESTUTIL_PATH,
@@ -167,11 +168,18 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
                     sources=sources,
                     options=options,
                     alt_lib_path='.')
+                errors = Errors()
+                compiler_options = CompilerOptions(multi_file=self.multi_file)
                 cfiles = emitmodule.compile_modules_to_c(
                     result,
                     module_names=module_names,
                     shared_lib_name=lib_name,
-                    compiler_options=CompilerOptions(multi_file=self.multi_file))
+                    compiler_options=compiler_options,
+                    errors=errors,
+                )
+                if errors.num_errors:
+                    errors.flush_errors()
+                    assert False, "Compile error"
             except CompileError as e:
                 for line in e.messages:
                     print(line)
diff --git a/mypyc/test/testutil.py b/mypyc/test/testutil.py
@@ -17,6 +17,7 @@
 from mypyc import genops
 from mypyc.options import CompilerOptions
 from mypyc.ops import FuncIR
+from mypyc.errors import Errors
 from mypyc.test.config import test_data_prefix
 
 # The builtins stub used during icode generation test cases.
@@ -102,9 +103,12 @@ def build_ir_for_single_file(input_lines: List[str],
                          alt_lib_path=test_temp_dir)
     if result.errors:
         raise CompileError(result.errors)
-    _, modules, errors = genops.build_ir([result.files['__main__']], result.graph, result.types,
-                                         compiler_options)
-    assert errors == 0
+
+    errors = Errors()
+    _, modules = genops.build_ir(
+        [result.files['__main__']], result.graph, result.types,
+        compiler_options, errors)
+    assert errors.num_errors == 0
 
     module = modules[0][1]
     return module.functions
