Implement infrastructure for reports

Author: o11c

mypy/build.py

@@ -26,6 +26,7 @@
 from mypy.errors import Errors, CompileError
 from mypy import parse
 from mypy import stats
+from mypy.report import Reports
 
 
 # We need to know the location of this file to load data, but
@@ -46,6 +47,8 @@
 MODULE = 'module'                # Build/run module as a script
 PROGRAM_TEXT = 'program-text'    # Build/run command-line argument as a script
 TEST_BUILTINS = 'test-builtins'  # Use stub builtins to speed up tests
+DUMP_TYPE_STATS = 'dump-type-stats'
+DUMP_INFER_STATS = 'dump-infer-stats'
 
 # State ids. These describe the states a source file / module can be in a
 # build.
@@ -96,7 +99,7 @@ def build(program_path: str,
           output_dir: str = None,
           pyversion: int = 3,
           custom_typing_module: str = None,
-          html_report_dir: str = None,
+          report_dirs: Dict[str, str] = {},
           flags: List[str] = None,
           python_path: bool = False) -> BuildResult:
     """Build a mypy program.
@@ -148,6 +151,8 @@ def build(program_path: str,
     if alt_lib_path:
         lib_path.insert(0, alt_lib_path)
 
+    reports = Reports(data_dir, report_dirs)
+
     # Construct a build manager object that performs all the stages of the
     # build in the correct order.
     #
@@ -156,7 +161,7 @@ def build(program_path: str,
                            pyversion=pyversion, flags=flags,
                            ignore_prefix=os.getcwd(),
                            custom_typing_module=custom_typing_module,
-                           html_report_dir=html_report_dir)
+                           reports=reports)
 
     if program_text is None:
         program_path = program_path or lookup_program(module, lib_path)
@@ -171,8 +176,7 @@ def build(program_path: str,
     # initial state of all files) to the manager. The manager will process the
     # file and all dependant modules recursively.
     result = manager.process(UnprocessedFile(info, program_text))
-    if 'html-report' in flags:
-        stats.generate_html_index(html_report_dir)
+    reports.finish()
     return result
 
 
@@ -301,7 +305,7 @@ def __init__(self, data_dir: str,
                  flags: List[str],
                  ignore_prefix: str,
                  custom_typing_module: str,
-                 html_report_dir: str) -> None:
+                 reports: Reports) -> None:
         self.data_dir = data_dir
         self.errors = Errors()
         self.errors.set_ignore_prefix(ignore_prefix)
@@ -311,7 +315,7 @@ def __init__(self, data_dir: str,
         self.pyversion = pyversion
         self.flags = flags
         self.custom_typing_module = custom_typing_module
-        self.html_report_dir = html_report_dir
+        self.reports = reports
         self.semantic_analyzer = SemanticAnalyzer(lib_path, self.errors,
                                                   pyversion=pyversion)
         self.semantic_analyzer_pass3 = ThirdPass(self.errors)
@@ -813,7 +817,7 @@ class PartiallySemanticallyAnalyzedFile(ParsedFile):
     def process(self) -> None:
         """Perform final pass of semantic analysis and advance state."""
         self.semantic_analyzer_pass3().visit_file(self.tree, self.tree.path)
-        if 'dump-type-stats' in self.manager.flags:
+        if DUMP_TYPE_STATS in self.manager.flags:
             stats.dump_type_stats(self.tree, self.tree.path)
         self.switch_state(SemanticallyAnalyzedFile(self.info(), self.tree))
 
@@ -826,14 +830,10 @@ def process(self) -> None:
         """Type check file and advance to the next state."""
         if self.manager.target >= TYPE_CHECK:
             self.type_checker().visit_file(self.tree, self.tree.path)
-            if 'dump-infer-stats' in self.manager.flags:
+            if DUMP_INFER_STATS in self.manager.flags:
                 stats.dump_type_stats(self.tree, self.tree.path, inferred=True,
                                       typemap=self.manager.type_checker.type_map)
-            elif 'html-report' in self.manager.flags:
-                stats.generate_html_report(
-                    self.tree, self.tree.path,
-                    type_map=self.manager.type_checker.type_map,
-                    output_dir=self.manager.html_report_dir)
+            self.manager.reports.file(self.tree, type_map=self.manager.type_checker.type_map)
 
         # FIX remove from active state list to speed up processing
 

mypy/main.py

@@ -8,7 +8,7 @@
 import tempfile
 
 import typing
-from typing import List, Tuple
+from typing import Dict, List, Tuple
 
 from mypy import build
 from mypy.errors import CompileError
@@ -23,7 +23,7 @@ def __init__(self) -> None:
         self.build_flags = []  # type: List[str]
         self.pyversion = 3
         self.custom_typing_module = None  # type: str
-        self.html_report_dir = None  # type: str
+        self.report_dirs = {} # type: Dict[str, str]
         self.python_path = False
 
 
@@ -75,7 +75,7 @@ def type_check_only(path: str, module: str, program_text: str, bin_dir: str, opt
                 target=build.TYPE_CHECK,
                 pyversion=options.pyversion,
                 custom_typing_module=options.custom_typing_module,
-                html_report_dir=options.html_report_dir,
+                report_dirs=options.report_dirs,
                 flags=options.build_flags,
                 python_path=options.python_path)
 
@@ -108,17 +108,18 @@ def process_options(args: List[str]) -> Tuple[str, str, str, Options]:
             help = True
             args = args[1:]
         elif args[0] == '--stats':
-            options.build_flags.append('dump-type-stats')
+            options.build_flags.append(build.DUMP_TYPE_STATS)
             args = args[1:]
         elif args[0] == '--inferstats':
-            options.build_flags.append('dump-infer-stats')
+            options.build_flags.append(build.DUMP_INFER_STATS)
             args = args[1:]
         elif args[0] == '--custom-typing' and args[1:]:
             options.custom_typing_module = args[1]
             args = args[2:]
-        elif args[0] == '--html-report' and args[1:]:
-            options.html_report_dir = args[1]
-            options.build_flags.append('html-report')
+        elif args[0] in ('--html-report', '--old-html-report') and args[1:]:
+            report_type = args[0][2:-7]
+            report_dir = args[1]
+            options.report_dirs[report_type] = report_dir
             args = args[2:]
         elif args[0] == '--use-python-path':
             options.python_path = True
@@ -161,7 +162,8 @@ def usage(msg: str = None) -> None:
 
 Optional arguments:
   -h, --help         print this help message and exit
-  --html-report dir  generate a HTML report of type precision under dir/
+  --<fmt>-report dir generate a <fmt> report of type precision under dir/
+                     <fmt> may be one of: html, old-html.
   -m mod             type check module
   -c string          type check string
   --verbose          more verbose messages

mypy/report.py

@@ -0,0 +1,63 @@
+"""Classes for producing HTML reports about imprecision."""
+
+from abc import ABCMeta, abstractmethod
+
+from typing import Callable, Dict, List
+
+from mypy.types import Type
+from mypy.nodes import MypyFile, Node
+from mypy import stats
+
+
+reporter_classes = {} # type: Dict[str, Callable[[Reports, str], AbstractReporter]]
+
+
+class Reports:
+    def __init__(self, data_dir: str, report_dirs: Dict[str, str]) -> None:
+        self.data_dir = data_dir
+        self.reporters = [] # type: List[AbstractReporter]
+
+        for report_type, report_dir in sorted(report_dirs.items()):
+            self.add_report(report_type, report_dir)
+
+    def add_report(self, report_type: str, report_dir: str) -> 'AbstractReporter':
+        reporter_cls = reporter_classes[report_type]
+        reporter = reporter_cls(self, report_dir)
+        self.reporters.append(reporter)
+
+    def file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        for reporter in self.reporters:
+            reporter.on_file(tree, type_map)
+
+    def finish(self) -> None:
+        for reporter in self.reporters:
+            reporter.on_finish()
+
+
+class AbstractReporter(metaclass=ABCMeta):
+    def __init__(self, reports: Reports, output_dir: str) -> None:
+        self.output_dir = output_dir
+
+    @abstractmethod
+    def on_file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        pass
+
+    @abstractmethod
+    def on_finish(self) -> None:
+        pass
+
+class OldHtmlReporter(AbstractReporter):
+    """Old HTML reporter.
+
+    This just calls the old functions in `stats`, which use global
+    variables to preserve state for the index.
+    """
+
+    def on_file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        stats.generate_html_report(tree, tree.path, type_map, self.output_dir)
+
+    def on_finish(self) -> None:
+        stats.generate_html_index(self.output_dir)
+reporter_classes['old-html'] = OldHtmlReporter
+
+reporter_classes['html'] = reporter_classes['old-html']