Add rudimentary mypy type checking

Add a very lax mypy configuration, add it to tox -e linting, and
fix/ignore the few errors that come up. The idea is to get it running
before diving in too much.

This enables:

- Progressively adding type annotations and enabling more strict
  options, which will improve the codebase (IMO).

- Annotating the public API in-line, and eventually exposing it to
  library users who use type checkers (with a py.typed file).

Though, none of this is done yet.

Refs #3342.

Author: bluetech

.gitignore

@@ -35,6 +35,7 @@ env/
 .tox
 .cache
 .pytest_cache
+.mypy_cache
 .coverage
 .coverage.*
 coverage.xml

.pre-commit-config.yaml

@@ -28,6 +28,7 @@ repos:
     hooks:
     -   id: flake8
         language_version: python3
+        additional_dependencies: [flake8-typing-imports]
 -   repo: https://github.com/asottile/reorder_python_imports
     rev: v1.4.0
     hooks:
@@ -42,6 +43,15 @@ repos:
     rev: v1.4.0
     hooks:
     -   id: rst-backticks
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.711
+    hooks:
+    -   id: mypy
+        name: mypy (src)
+        files: ^src/
+    -   id: mypy
+        name: mypy (testing)
+        files: ^testing/
 -   repo: local
     hooks:
     -   id: rst

bench/bench.py

@@ -6,7 +6,7 @@
     import pstats
 
     script = sys.argv[1:] if len(sys.argv) > 1 else ["empty.py"]
-    stats = cProfile.run("pytest.cmdline.main(%r)" % script, "prof")
+    cProfile.run("pytest.cmdline.main(%r)" % script, "prof")
     p = pstats.Stats("prof")
     p.strip_dirs()
     p.sort_stats("cumulative")

setup.cfg

@@ -61,3 +61,11 @@ ignore =
 
 [devpi:upload]
 formats = sdist.tgz,bdist_wheel
+
+[mypy]
+ignore_missing_imports = True
+no_implicit_optional = True
+strict_equality = True
+warn_redundant_casts = True
+warn_return_any = True
+warn_unused_configs = True

src/_pytest/_argcomplete.py

@@ -56,6 +56,7 @@
 import os
 import sys
 from glob import glob
+from typing import Optional
 
 
 class FastFilesCompleter:
@@ -91,7 +92,7 @@ def __call__(self, prefix, **kwargs):
         import argcomplete.completers
     except ImportError:
         sys.exit(-1)
-    filescompleter = FastFilesCompleter()
+    filescompleter = FastFilesCompleter()  # type: Optional[FastFilesCompleter]
 
     def try_argcomplete(parser):
         argcomplete.autocomplete(parser, always_complete_options=False)

src/_pytest/_code/code.py

@@ -33,7 +33,8 @@ def __init__(self, rawcode):
     def __eq__(self, other):
         return self.raw == other.raw
 
-    __hash__ = None
+    # Ignore type because of https://github.com/python/mypy/issues/4266.
+    __hash__ = None  # type: ignore
 
     def __ne__(self, other):
         return not self == other
@@ -188,11 +189,11 @@ def path(self):
         """ path to the source code """
         return self.frame.code.path
 
-    def getlocals(self):
+    @property
+    def locals(self):
+        """ locals of underlaying frame """
         return self.frame.f_locals
 
-    locals = property(getlocals, None, None, "locals of underlaying frame")
-
     def getfirstlinesource(self):
         return self.frame.code.firstlineno
 
@@ -255,11 +256,11 @@ def __str__(self):
             line = "???"
         return "  File %r:%d in %s\n  %s\n" % (fn, self.lineno + 1, name, line)
 
+    @property
     def name(self):
+        """ co_name of underlaying code """
         return self.frame.code.raw.co_name
 
-    name = property(name, None, None, "co_name of underlaying code")
-
 
 class Traceback(list):
     """ Traceback objects encapsulate and offer higher level

src/_pytest/_code/source.py

@@ -44,7 +44,8 @@ def __eq__(self, other):
                 return str(self) == other
             return False
 
-    __hash__ = None
+    # Ignore type because of https://github.com/python/mypy/issues/4266.
+    __hash__ = None  # type: ignore
 
     def __getitem__(self, key):
         if isinstance(key, int):

src/_pytest/assertion/rewrite.py

@@ -12,6 +12,10 @@
 import sys
 import tokenize
 import types
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Set
 
 import atomicwrites
 
@@ -459,39 +463,40 @@ def _fix(node, lineno, col_offset):
     return node
 
 
-def _get_assertion_exprs(src: bytes):  # -> Dict[int, str]
+def _get_assertion_exprs(src: bytes) -> Dict[int, str]:
     """Returns a mapping from {lineno: "assertion test expression"}"""
-    ret = {}
+    ret = {}  # type: Dict[int, str]
 
     depth = 0
-    lines = []
-    assert_lineno = None
-    seen_lines = set()
+    lines = []  # type: List[str]
+    assert_lineno = None  # type: Optional[int]
+    seen_lines = set()  # type: Set[int]
 
     def _write_and_reset() -> None:
         nonlocal depth, lines, assert_lineno, seen_lines
+        assert assert_lineno is not None
         ret[assert_lineno] = "".join(lines).rstrip().rstrip("\\")
         depth = 0
         lines = []
         assert_lineno = None
         seen_lines = set()
 
     tokens = tokenize.tokenize(io.BytesIO(src).readline)
-    for tp, src, (lineno, offset), _, line in tokens:
-        if tp == tokenize.NAME and src == "assert":
+    for tp, source, (lineno, offset), _, line in tokens:
+        if tp == tokenize.NAME and source == "assert":
             assert_lineno = lineno
         elif assert_lineno is not None:
             # keep track of depth for the assert-message `,` lookup
-            if tp == tokenize.OP and src in "([{":
+            if tp == tokenize.OP and source in "([{":
                 depth += 1
-            elif tp == tokenize.OP and src in ")]}":
+            elif tp == tokenize.OP and source in ")]}":
                 depth -= 1
 
             if not lines:
                 lines.append(line[offset:])
                 seen_lines.add(lineno)
             # a non-nested comma separates the expression from the message
-            elif depth == 0 and tp == tokenize.OP and src == ",":
+            elif depth == 0 and tp == tokenize.OP and source == ",":
                 # one line assert with message
                 if lineno in seen_lines and len(lines) == 1:
                     offset_in_trimmed = offset + len(lines[-1]) - len(line)

src/_pytest/capture.py

@@ -547,6 +547,8 @@ def __init__(self, targetfd, tmpfile=None):
             self.start = lambda: None
             self.done = lambda: None
         else:
+            self.start = self._start
+            self.done = self._done
             if targetfd == 0:
                 assert not tmpfile, "cannot set tmpfile with stdin"
                 tmpfile = open(os.devnull, "r")
@@ -568,7 +570,7 @@ def __repr__(self):
             self.targetfd, getattr(self, "targetfd_save", None), self._state
         )
 
-    def start(self):
+    def _start(self):
         """ Start capturing on targetfd using memorized tmpfile. """
         try:
             os.fstat(self.targetfd_save)
@@ -585,7 +587,7 @@ def snap(self):
         self.tmpfile.truncate()
         return res
 
-    def done(self):
+    def _done(self):
         """ stop capturing, restore streams, return original capture file,
         seeked to position zero. """
         targetfd_save = self.__dict__.pop("targetfd_save")
@@ -618,7 +620,8 @@ class FDCapture(FDCaptureBinary):
     snap() produces text
     """
 
-    EMPTY_BUFFER = str()
+    # Ignore type because it doesn't match the type in the superclass (bytes).
+    EMPTY_BUFFER = str()  # type: ignore
 
     def snap(self):
         res = super().snap()
@@ -679,7 +682,8 @@ def writeorg(self, data):
 
 
 class SysCaptureBinary(SysCapture):
-    EMPTY_BUFFER = b""
+    # Ignore type because it doesn't match the type in the superclass (str).
+    EMPTY_BUFFER = b""  # type: ignore
 
     def snap(self):
         res = self.tmpfile.buffer.getvalue()

src/_pytest/debugging.py

@@ -74,7 +74,7 @@ class pytestPDB:
 
     _pluginmanager = None
     _config = None
-    _saved = []
+    _saved = []  # type: list
     _recursive_debug = 0
     _wrapped_pdb_cls = None