Fix most errors reported by --disallow-untyped-defs/calls. (#1814)

I didn't get to everything:

- A whole bunch of untyped calls are left in strconv.py; this code
uses a few nasty data types (a list of strings and variously-sized
tuples) and a ton of node types from nodes, and I got tired of
typing.

- A few untyped stdlib calls are left because the stubs for traceback
and argparse are basically untyped.

- A few nested functions where I couldn't figure out the argument
types; here I used some Any types so no errors are reported.

Author: gvanrossum

mypy/build.py

@@ -507,7 +507,7 @@ def remove_cwd_prefix_from_path(p: str) -> str:
 find_module_listdir_cache = {}  # type: Dict[str, Optional[List[str]]]
 
 
-def find_module_clear_caches():
+def find_module_clear_caches() -> None:
     find_module_cache.clear()
     find_module_dir_cache.clear()
     find_module_listdir_cache.clear()
@@ -546,12 +546,11 @@ def is_file(path: str) -> bool:
     return os.path.isfile(path)
 
 
-def find_module(id: str, lib_path: Iterable[str]) -> str:
+def find_module(id: str, lib_path_arg: Iterable[str]) -> str:
     """Return the path of the module source file, or None if not found."""
-    if not isinstance(lib_path, tuple):
-        lib_path = tuple(lib_path)
+    lib_path = tuple(lib_path_arg)
 
-    def find():
+    def find() -> Optional[str]:
         # If we're looking for a module like 'foo.bar.baz', it's likely that most of the
         # many elements of lib_path don't even have a subdirectory 'foo/bar'.  Discover
         # that only once and cache it for when we look for modules like 'foo.bar.blah'
@@ -767,7 +766,7 @@ def select_options_affecting_cache(options: Options) -> Mapping[str, bool]:
 ]
 
 
-def random_string():
+def random_string() -> str:
     return binascii.hexlify(os.urandom(8)).decode('ascii')
 
 

mypy/checker.py

@@ -167,7 +167,7 @@ def visit_file(self, file_node: MypyFile, path: str) -> None:
                 self.fail(messages.ALL_MUST_BE_SEQ_STR.format(str_seq_s, all_s),
                           all_.node)
 
-    def check_second_pass(self):
+    def check_second_pass(self) -> None:
         """Run second pass of type checking which goes through deferred nodes."""
         self.pass_num = 1
         for node, type_name in self.deferred_nodes:

mypy/checkexpr.py

@@ -1192,7 +1192,7 @@ def visit_index_expr_helper(self, e: IndexExpr) -> Type:
             e.method_type = method_type
             return result
 
-    def visit_tuple_slice_helper(self, left_type: TupleType, slic: SliceExpr):
+    def visit_tuple_slice_helper(self, left_type: TupleType, slic: SliceExpr) -> Type:
         begin = None  # type: int
         end = None  # type: int
         stride = None  # type:int
@@ -1469,7 +1469,7 @@ def check_generator_or_comprehension(self, gen: GeneratorExpr,
         return self.check_call(constructor,
                                [gen.left_expr], [nodes.ARG_POS], gen)[0]
 
-    def visit_dictionary_comprehension(self, e: DictionaryComprehension):
+    def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> Type:
         """Type check a dictionary comprehension."""
         self.check_for_comp(e)
 

mypy/checkstrformat.py

@@ -25,10 +25,10 @@ def __init__(self, key: str, flags: str, width: str, precision: str, type: str)
         self.precision = precision
         self.type = type
 
-    def has_key(self):
+    def has_key(self) -> bool:
         return self.key is not None
 
-    def has_star(self):
+    def has_star(self) -> bool:
         return self.width == '*' or self.precision == '*'
 
 

mypy/docstring.py

@@ -83,23 +83,23 @@
 
 
 class DocstringTypes(object):
-    def __init__(self):
+    def __init__(self) -> None:
         self.args = OrderedDict()  # type: Dict[str, Optional[str]]
         self.rettype = None  # type: Optional[str]
 
     def as_type_str(self) -> str:
         return ('(' + ','.join([v or 'Any' for v in self.args.values()]) +
                 ') -> ' + (self.rettype or 'Any'))
 
-    def __str__(self):
+    def __str__(self) -> str:
         return repr({'args': self.args, 'return': self.rettype})
 
 
 def wsprefix(s: str) -> str:
     return s[:len(s) - len(s.lstrip())]
 
 
-def scrubtype(typestr: Optional[str], only_known=False) -> Optional[str]:
+def scrubtype(typestr: Optional[str], only_known: bool =False) -> Optional[str]:
     if typestr is None:
         return typestr
 

mypy/fastparse.py

@@ -36,8 +36,9 @@
               ' Python 3.3 and greater.')
     sys.exit(1)
 
-T = TypeVar('T')
-U = TypeVar('U')
+T = TypeVar('T', bound=Union[ast35.expr, ast35.stmt])
+U = TypeVar('U', bound=Node)
+V = TypeVar('V')
 
 TYPE_COMMENT_SYNTAX_ERROR = 'syntax error in type comment'
 TYPE_COMMENT_AST_ERROR = 'invalid type comment'
@@ -92,16 +93,16 @@ def parse_type_comment(type_comment: str, line: int) -> Type:
         return TypeConverter(line=line).visit(typ.body)
 
 
-def with_line(f: Callable[[Any, T], U]) -> Callable[[Any, T], U]:
+def with_line(f: Callable[['ASTConverter', T], U]) -> Callable[['ASTConverter', T], U]:
     @wraps(f)
-    def wrapper(self, ast):
+    def wrapper(self: 'ASTConverter', ast: T) -> U:
         node = f(self, ast)
         node.set_line(ast.lineno)
         return node
     return wrapper
 
 
-def find(f: Callable[[T], bool], seq: Sequence[T]) -> T:
+def find(f: Callable[[V], bool], seq: Sequence[V]) -> V:
     for item in seq:
         if f(item):
             return item
@@ -308,7 +309,7 @@ def set_type_optional(self, type: Type, initializer: Node) -> None:
             type.optional = optional
 
     def transform_args(self, args: ast35.arguments, line: int) -> List[Argument]:
-        def make_argument(arg, default, kind):
+        def make_argument(arg: ast35.arg, default: Optional[ast35.expr], kind: int) -> Argument:
             arg_type = TypeConverter(line=line).visit(arg.annotation)
             converted_default = self.visit(default)
             self.set_type_optional(arg_type, converted_default)
@@ -531,7 +532,7 @@ def visit_BoolOp(self, n: ast35.BoolOp) -> Node:
             raise RuntimeError('unknown BoolOp ' + str(type(n)))
 
         # potentially inefficient!
-        def group(vals):
+        def group(vals: List[Node]) -> Node:
             if len(vals) == 2:
                 return OpExpr(op, vals[0], vals[1])
             else:
@@ -649,7 +650,7 @@ def visit_Compare(self, n: ast35.Compare) -> Node:
     # keyword = (identifier? arg, expr value)
     @with_line
     def visit_Call(self, n: ast35.Call) -> Node:
-        def is_star2arg(k):
+        def is_star2arg(k: ast35.keyword) -> bool:
             return k.arg is None
 
         arg_types = self.visit_list(

mypy/git.py

@@ -70,23 +70,23 @@ def warn_no_git_executable() -> None:
           "git executable not in path.", file=sys.stderr)
 
 
-def warn_dirty(dir) -> None:
+def warn_dirty(dir: str) -> None:
     print("Warning: git module '{}' has uncommitted changes.".format(dir),
           file=sys.stderr)
     print("Go to the directory", file=sys.stderr)
     print("  {}".format(dir), file=sys.stderr)
     print("and commit or reset your changes", file=sys.stderr)
 
 
-def warn_extra_files(dir) -> None:
+def warn_extra_files(dir: str) -> None:
     print("Warning: git module '{}' has untracked files.".format(dir),
           file=sys.stderr)
     print("Go to the directory", file=sys.stderr)
     print("  {}".format(dir), file=sys.stderr)
     print("and add & commit your new files.", file=sys.stderr)
 
 
-def chdir_prefix(dir) -> str:
+def chdir_prefix(dir: str) -> str:
     """Return the command to change to the target directory, plus '&&'."""
     if os.path.relpath(dir) != ".":
         return "cd " + pipes.quote(dir) + " && "

mypy/lex.py

@@ -142,7 +142,7 @@ def __init__(self, string: str, type: int, message: str = None) -> None:
         self.type = type
         self.message = message
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.message:
             return 'LexError(%s)' % self.message
         else:

mypy/main.py

@@ -5,7 +5,7 @@
 import re
 import sys
 
-from typing import Optional, Dict, List, Set, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from mypy import build
 from mypy import defaults
@@ -86,21 +86,21 @@ def type_check_only(sources: List[BuildSource],
 
 
 class SplitNamespace:
-    def __init__(self, standard_namespace, alt_namespace, alt_prefix):
+    def __init__(self, standard_namespace: object, alt_namespace: object, alt_prefix: str) -> None:
         self.__dict__['_standard_namespace'] = standard_namespace
         self.__dict__['_alt_namespace'] = alt_namespace
         self.__dict__['_alt_prefix'] = alt_prefix
 
-    def _get(self):
+    def _get(self) -> Tuple[Any, Any]:
         return (self._standard_namespace, self._alt_namespace)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name.startswith(self._alt_prefix):
             setattr(self._alt_namespace, name[len(self._alt_prefix):], value)
         else:
             setattr(self._standard_namespace, name, value)
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         if name.startswith(self._alt_prefix):
             return getattr(self._alt_namespace, name[len(self._alt_prefix):])
         else:
@@ -121,7 +121,7 @@ def process_options(args: List[str]) -> Tuple[List[BuildSource], Options]:
     parser = argparse.ArgumentParser(prog='mypy', epilog=FOOTER,
                                      formatter_class=help_factory)
 
-    def parse_version(v):
+    def parse_version(v: str) -> Tuple[int, int]:
         m = re.match(r'\A(\d)\.(\d+)\Z', v)
         if m:
             return int(m.group(1)), int(m.group(2))

mypy/meet.py

@@ -270,10 +270,10 @@ def visit_type_type(self, t: TypeType) -> Type:
         else:
             return self.default(self.s)
 
-    def meet(self, s, t):
+    def meet(self, s: Type, t: Type) -> Type:
         return meet_types(s, t)
 
-    def default(self, typ):
+    def default(self, typ: Type) -> Type:
         if isinstance(typ, UnboundType):
             return AnyType()
         elif isinstance(typ, Void) or isinstance(typ, ErrorType):

mypy/nodes.py

@@ -343,6 +343,12 @@ def deserialize(cls, data: JsonDict) -> 'OverloadedFuncDef':
 class Argument(Node):
     """A single argument in a FuncItem."""
 
+    variable = None  # type: Var
+    type_annotation = None  # type: Optional[mypy.types.Type]
+    initializater = None  # type: Optional[Expression]
+    kind = None  # type: int
+    initialization_statement = None  # type: Optional[AssignmentStmt]
+
     def __init__(self, variable: 'Var', type_annotation: 'Optional[mypy.types.Type]',
             initializer: Optional[Expression], kind: int,
             initialization_statement: Optional['AssignmentStmt'] = None) -> None:
@@ -438,7 +444,7 @@ def set_line(self, target: Union[Token, Node, int]) -> Node:
             arg.set_line(self.line)
         return self
 
-    def is_dynamic(self):
+    def is_dynamic(self) -> bool:
         return self.type is None
 
 

mypy/options.py

@@ -1,5 +1,6 @@
 from mypy import defaults
 import pprint
+from typing import Any
 
 
 class BuildType:
@@ -55,11 +56,11 @@ def __init__(self) -> None:
         self.fast_parser = False
         self.incremental = False
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return self.__class__ == other.__class__ and self.__dict__ == other.__dict__
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not self == other
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return 'Options({})'.format(pprint.pformat(self.__dict__))

mypy/parse.py

@@ -1528,7 +1528,7 @@ def parse_set_expr(self, first: Node) -> SetExpr:
         expr = SetExpr(items)
         return expr
 
-    def parse_set_comprehension(self, expr: Node):
+    def parse_set_comprehension(self, expr: Node) -> SetComprehension:
         gen = self.parse_generator_expr(expr)
         self.expect('}')
         set_comp = SetComprehension(gen)
@@ -2000,7 +2000,7 @@ def token_repr(tok: Token) -> str:
     # Parse a file and dump the AST (or display errors).
     import sys
 
-    def usage():
+    def usage() -> None:
         print('Usage: parse.py [--py2] [--quiet] FILE [...]', file=sys.stderr)
         sys.exit(2)
 

mypy/report.py

@@ -64,7 +64,7 @@ def __init__(self) -> None:
         super().__init__()
         self.counts = [0, 0]
 
-    def visit_func_def(self, defn: FuncDef):
+    def visit_func_def(self, defn: FuncDef) -> None:
         self.counts[defn.type is not None] += 1
 
 

mypy/semanal.py

@@ -605,7 +605,7 @@ def unbind_class_type_vars(self) -> None:
     def analyze_class_decorator(self, defn: ClassDef, decorator: Node) -> None:
         decorator.accept(self)
 
-    def setup_is_builtinclass(self, defn: ClassDef):
+    def setup_is_builtinclass(self, defn: ClassDef) -> None:
         for decorator in defn.decorators:
             if refers_to_fullname(decorator, 'typing.builtinclass'):
                 defn.is_builtinclass = True

mypy/solve.py

@@ -12,7 +12,7 @@
 
 
 def solve_constraints(vars: List[TypeVarId], constraints: List[Constraint],
-                      strict=True) -> List[Type]:
+                      strict: bool =True) -> List[Type]:
     """Solve type constraints.
 
     Return the best type(s) for type variables; each type can be None if the value of the variable

mypy/strconv.py

@@ -3,7 +3,7 @@
 import re
 import os
 
-import typing
+from typing import Any, List
 
 from mypy.util import dump_tagged, short_type
 import mypy.nodes
@@ -21,7 +21,7 @@ class StrConv(NodeVisitor[str]):
         ExpressionStmt:1(
           IntExpr(1)))
     """
-    def dump(self, nodes, obj):
+    def dump(self, nodes: List[Any], obj: 'mypy.nodes.Node') -> str:
         """Convert a list of items to a multiline pretty-printed string.
 
         The tag is produced from the type name of obj and its line
@@ -30,7 +30,7 @@ def dump(self, nodes, obj):
         """
         return dump_tagged(nodes, short_type(obj) + ':' + str(obj.line))
 
-    def func_helper(self, o):
+    def func_helper(self, o: 'mypy.nodes.FuncItem') -> List[Any]:
         """Return a list in a format suitable for dump() that represents the
         arguments and the body of a function. The caller can then decorate the
         array with information specific to methods, global functions or
@@ -50,7 +50,7 @@ def func_helper(self, o):
                 extra.append(('VarArg', [o.arguments[i].variable]))
             elif kind == mypy.nodes.ARG_STAR2:
                 extra.append(('DictVarArg', [o.arguments[i].variable]))
-        a = []
+        a = []  # type: List[Any]
         if args:
             a.append(('Args', args))
         if o.type:
@@ -65,9 +65,9 @@ def func_helper(self, o):
 
     # Top-level structures
 
-    def visit_mypy_file(self, o):
+    def visit_mypy_file(self, o: 'mypy.nodes.MypyFile') -> str:
         # Skip implicit definitions.
-        a = [o.defs]
+        a = [o.defs]  # type: List[Any]
         if o.is_bom:
             a.insert(0, 'BOM')
         # Omit path to special file with name "main". This is used to simplify
@@ -82,7 +82,7 @@ def visit_mypy_file(self, o):
                                                     for line in sorted(o.ignored_lines)))
         return self.dump(a, o)
 
-    def visit_import(self, o):
+    def visit_import(self, o: 'mypy.nodes.Import') -> str:
         a = []
         for id, as_id in o.ids:
             if as_id is not None: