Add Error format support, and JSON output option

mypy/build.py

@@ -34,6 +34,7 @@
 from mypy.checker import TypeChecker
 from mypy.indirection import TypeIndirectionVisitor
 from mypy.errors import Errors, CompileError, ErrorInfo, report_internal_error
+from mypy.error_formatter import ErrorFormatter, JSONFormatter
 from mypy.util import (
     DecodeError, decode_python_encoding, is_sub_path, get_mypy_comments, module_prefix,
     read_py_file, hash_digest, is_typeshed_file, is_stub_package_file, get_top_two_prefixes
@@ -245,6 +246,7 @@ def _build(sources: List[BuildSource],
                            plugin=plugin,
                            plugins_snapshot=snapshot,
                            errors=errors,
+                           error_formatter=JSONFormatter() if options.output == 'json' else None,
                            flush_errors=flush_errors,
                            fscache=fscache,
                            stdout=stdout,
@@ -583,6 +585,7 @@ def __init__(self, data_dir: str,
                  fscache: FileSystemCache,
                  stdout: TextIO,
                  stderr: TextIO,
+                 error_formatter: Optional['ErrorFormatter'] = None,
                  ) -> None:
         self.stats: Dict[str, Any] = {}  # Values are ints or floats
         self.stdout = stdout
@@ -591,6 +594,7 @@ def __init__(self, data_dir: str,
         self.data_dir = data_dir
         self.errors = errors
         self.errors.set_ignore_prefix(ignore_prefix)
+        self.error_formatter = error_formatter
         self.search_paths = search_paths
         self.source_set = source_set
         self.reports = reports
@@ -3156,7 +3160,9 @@ def process_stale_scc(graph: Graph, scc: List[str], manager: BuildManager) -> No
         for id in stale:
             graph[id].transitive_error = True
     for id in stale:
-        manager.flush_errors(manager.errors.file_messages(graph[id].xpath), False)
+        errors = manager.errors.file_messages(
+            graph[id].xpath, formatter=manager.error_formatter)
+        manager.flush_errors(errors, False)
         graph[id].write_cache()
         graph[id].mark_as_rechecked()
 

mypy/error_formatter.py

@@ -0,0 +1,26 @@
+import json
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mypy.errors import ErrorTuple
+
+
+class ErrorFormatter(ABC):
+    """Defines how errors are formatted before being printed."""
+    @abstractmethod
+    def report_error(self, error: 'ErrorTuple') -> str:
+        raise NotImplementedError
+
+
+class JSONFormatter(ErrorFormatter):
+    def report_error(self, error: 'ErrorTuple') -> str:
+        file, line, column, severity, message, _, errorcode = error
+        return json.dumps({
+            'file': file,
+            'line': line,
+            'column': column,
+            'severity': severity,
+            'message': message,
+            'code': None if errorcode is None else errorcode.code,
+        })

mypy/errors.py

@@ -6,6 +6,7 @@
 
 from typing import Tuple, List, TypeVar, Set, Dict, Optional, TextIO, Callable
 from typing_extensions import Final
+from mypy.error_formatter import ErrorFormatter
 
 from mypy.scope import Scope
 from mypy.options import Options
@@ -575,19 +576,27 @@ def format_messages(self, error_info: List[ErrorInfo],
                     a.append(' ' * (DEFAULT_SOURCE_OFFSET + column) + '^')
         return a
 
-    def file_messages(self, path: str) -> List[str]:
+    def file_messages(self, path: str, formatter: Optional[ErrorFormatter] = None) -> List[str]:
         """Return a string list of new error messages from a given file.
 
         Use a form suitable for displaying to the user.
         """
         if path not in self.error_info_map:
             return []
+
+        error_info = self.error_info_map[path]
+        if formatter is not None:
+            error_info = [info for info in error_info if not info.hidden]
+            errors = self.render_messages(self.sort_messages(error_info))
+            errors = self.remove_duplicates(errors)
+            return [formatter.report_error(err) for err in errors]
+
         self.flushed_files.add(path)
         source_lines = None
         if self.pretty:
             assert self.read_source
             source_lines = self.read_source(path)
-        return self.format_messages(self.error_info_map[path], source_lines)
+        return self.format_messages(error_info, source_lines)
 
     def new_messages(self) -> List[str]:
         """Return a string list of new error messages.

mypy/main.py

@@ -490,6 +490,9 @@ def add_invertible_flag(flag: str,
         help="Show program's version number and exit",
         stdout=stdout)
 
+    general_group.add_argument(
+        '-O', '--output', metavar='FORMAT', help="Set a custom output format")
+
     config_group = parser.add_argument_group(
         title='Config file',
         description="Use a config file instead of command line arguments. "

mypy/options.py

@@ -302,6 +302,9 @@ def __init__(self) -> None:
         # -1 means unlimited.
         self.many_errors_threshold = defaults.MANY_ERRORS_THRESHOLD
 
+        # Sets output format
+        self.output = ""
+
     # To avoid breaking plugin compatibility, keep providing new_semantic_analyzer
     @property
     def new_semantic_analyzer(self) -> bool: