more cleanups

extensions/mypy_extensions.py

@@ -14,6 +14,7 @@
 # the (convenient) behavior of types provided by typing module.
 from typing import _type_check  # type: ignore
 
+
 def _check_fails(cls, other):
     try:
         if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools', 'typing']:
@@ -93,23 +94,36 @@ class Point2D(TypedDict):
     syntax forms work for Python 2.7 and 3.2+
     """
 
+
 def Arg(typ=Any, name=None):
+    """A normal positional argument"""
     return typ
 
+
 def DefaultArg(typ=Any, name=None):
+    """A positional argument with a default value"""
     return typ
 
+
 def NamedArg(typ=Any, name=None):
+    """A keyword-only argument"""
     return typ
 
+
 def DefaultNamedArg(typ=Any, name=None):
+    """A keyword-only argument with a default value"""
     return typ
 
+
 def VarArg(typ=Any):
+    """A *args-style variadic positional argument"""
     return typ
 
+
 def KwArg(typ=Any):
+    """A **kwargs-style variadic keyword argument"""
     return typ
 
+
 # Return type that indicates a function does not return
 class NoReturn: pass

mypy/fastparse.py

@@ -446,7 +446,7 @@ def make_argument(arg: ast3.arg, default: Optional[ast3.expr], kind: int) -> Arg
             new_args.append(make_argument(args.kwarg, None, ARG_STAR2))
             names.append(args.kwarg)
 
-        def fail_arg(msg: str, arg: ast3.arg):
+        def fail_arg(msg: str, arg: ast3.arg) -> None:
             self.fail(msg, arg.lineno, arg.col_offset)
 
         check_arg_names([name.arg for name in names], names, fail_arg)
@@ -957,7 +957,7 @@ def __init__(self, errors: Errors, line: int = -1) -> None:
         self.line = line
         self.node_stack = []  # type: List[ast3.AST]
 
-    def visit(self, node):
+    def visit(self, node) -> Type:
         """Modified visit -- keep track of the stack of nodes"""
         self.node_stack.append(node)
         try:
@@ -1021,19 +1021,16 @@ def visit_Call(self, e: ast3.Call) -> Type:
                     value.lineno, value.col_offset)
         return CallableArgument(typ, name, constructor, e.lineno, e.col_offset)
 
-
     def translate_argument_list(self, l: Sequence[ast3.AST]) -> TypeList:
-        types = []  # type: List[Type]
-        names = []  # type: List[Optional[str]]
-        kinds = []  # type: List[int]
         return TypeList([self.visit(e) for e in l], line=self.line)
 
     def _extract_str(self, n: ast3.expr) -> str:
         if isinstance(n, ast3.Str):
             return n.s.strip()
         elif isinstance(n, ast3.NameConstant) and str(n.value) == 'None':
             return None
-        self.fail('Expected string literal for argument name, got {}'.format(type(n).__name__), self.line, 0)
+        self.fail('Expected string literal for argument name, got {}'.format(
+            type(n).__name__), self.line, 0)
         return None
 
     def visit_Name(self, n: ast3.Name) -> Type:
@@ -1087,9 +1084,9 @@ def visit_Ellipsis(self, n: ast3.Ellipsis) -> Type:
 
     # List(expr* elts, expr_context ctx)
     def visit_List(self, n: ast3.List) -> Type:
-        l = len(n.elts)
         return self.translate_argument_list(n.elts)
 
+
 def stringify_name(n: ast3.AST) -> Optional[str]:
     if isinstance(n, ast3.Name):
         return n.id

mypy/nodes.py

@@ -2435,6 +2435,7 @@ def get_member_expr_fullname(expr: MemberExpr) -> str:
     if isinstance(obj, type) and issubclass(obj, SymbolNode) and obj is not SymbolNode
 }
 
+
 def check_arg_kinds(arg_kinds: List[int], nodes: List[T], fail: Callable[[str, T], None]) -> None:
     is_var_arg = False
     is_kw_arg = False
@@ -2444,8 +2445,8 @@ def check_arg_kinds(arg_kinds: List[int], nodes: List[T], fail: Callable[[str, T
         if kind == ARG_POS:
             if is_var_arg or is_kw_arg or seen_named or seen_opt:
                 fail("Required positional args may not appear "
-                          "after default, named or star args",
-                          node)
+                     "after default, named or star args",
+                     node)
                 break
         elif kind == ARG_OPT:
             if is_var_arg or is_kw_arg or seen_named:
@@ -2467,7 +2468,7 @@ def check_arg_kinds(arg_kinds: List[int], nodes: List[T], fail: Callable[[str, T
 
 
 def check_arg_names(names: List[str], nodes: List[T], fail: Callable[[str, T], None],
-                     description: str = 'function definition') -> None:
+                    description: str = 'function definition') -> None:
     seen_names = set()  # type: Set[str]
     for name, node in zip(names, nodes):
         if name is not None and name in seen_names:

mypy/typeanal.py

@@ -420,8 +420,8 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                         names.append(None)
                         kinds.append(ARG_POS)
 
-                check_arg_names(names, [t]*len(args), self.fail, "Callable")
-                check_arg_kinds(kinds, [t]*len(args), self.fail)
+                check_arg_names(names, [t] * len(args), self.fail, "Callable")
+                check_arg_kinds(kinds, [t] * len(args), self.fail)
                 return CallableType(self.anal_array(args),
                                     kinds,
                                     names,

mypy/types.py

@@ -222,6 +222,7 @@ def deserialize(cls, data: JsonDict) -> 'UnboundType':
         return UnboundType(data['name'],
                            [deserialize_type(a) for a in data['args']])
 
+
 class CallableArgument(Type):
     typ = None          # type: Type
     name = None         # type: Optional[str]
@@ -254,6 +255,7 @@ def deserialize(cls, data: JsonDict) -> 'CallableArgument':
             name=data['name'],
             constructor=data['constructor'])
 
+
 class TypeList(Type):
     """Information about argument types and names [...].
 
@@ -1431,9 +1433,9 @@ def visit_type_list(self, t: TypeList) -> str:
     def visit_callable_argument(self, t: CallableArgument) -> str:
         typ = t.typ.accept(self)
         if t.name is None:
-            return "{}({})".format(t.constructor, t.typ)
+            return "{}({})".format(t.constructor, typ)
         else:
-            return "{}({}, {})".format(t.constructor, t.typ, t.name)
+            return "{}({}, {})".format(t.constructor, typ, t.name)
 
     def visit_any(self, t: AnyType) -> str:
         return 'Any'

test-data/unit/parse.test

@@ -2392,7 +2392,7 @@ MypyFile:1(
   AssignmentStmt:1(
     NameExpr(f)
     NameExpr(None)
-    Callable?[<ArgumentList >, None?]))
+    Callable?[<TypeList >, None?]))
 
 [case testFunctionTypeWithArgument]
 f = None # type: Callable[[str], int]
@@ -2401,7 +2401,7 @@ MypyFile:1(
   AssignmentStmt:1(
     NameExpr(f)
     NameExpr(None)
-    Callable?[<ArgumentList str?>, int?]))
+    Callable?[<TypeList str?>, int?]))
 
 [case testFunctionTypeWithTwoArguments]
 f = None # type: Callable[[a[b], x.y], List[int]]
@@ -2410,7 +2410,7 @@ MypyFile:1(
   AssignmentStmt:1(
     NameExpr(f)
     NameExpr(None)
-    Callable?[<ArgumentList a?[b?], x.y?>, List?[int?]]))
+    Callable?[<TypeList a?[b?], x.y?>, List?[int?]]))
 
 [case testFunctionTypeWithExtraComma]
 def f(x: Callable[[str,], int]): pass
@@ -2420,7 +2420,7 @@ MypyFile:1(
     f
     Args(
       Var(x))
-    def (x: Callable?[<ArgumentList str?>, int?]) -> Any
+    def (x: Callable?[<TypeList str?>, int?]) -> Any
     Block:1(
       PassStmt:1())))