[clean-strict-optional] Clean-up the type checking files (#3957)

This makes another major piece of mypy `--strict-optional` clean: the type checking files.
After this PR there will be only single exception left `semanal.py`.

Author: ilevkivskyi

mypy/applytype.py

@@ -1,4 +1,4 @@
-from typing import List, Dict
+from typing import List, Dict, Sequence, Optional
 
 import mypy.subtypes
 from mypy.sametypes import is_same_type
@@ -8,7 +8,7 @@
 from mypy.nodes import Context
 
 
-def apply_generic_arguments(callable: CallableType, types: List[Type],
+def apply_generic_arguments(callable: CallableType, orig_types: Sequence[Optional[Type]],
                             msg: MessageBuilder, context: Context) -> CallableType:
     """Apply generic type arguments to a callable type.
 
@@ -18,10 +18,10 @@ def apply_generic_arguments(callable: CallableType, types: List[Type],
     Note that each type can be None; in this case, it will not be applied.
     """
     tvars = callable.variables
-    assert len(tvars) == len(types)
+    assert len(tvars) == len(orig_types)
     # Check that inferred type variable values are compatible with allowed
     # values and bounds.  Also, promote subtype values to allowed values.
-    types = types[:]
+    types = list(orig_types)
     for i, type in enumerate(types):
         values = callable.variables[i].values
         if values and type:
@@ -47,8 +47,9 @@ def apply_generic_arguments(callable: CallableType, types: List[Type],
     # Create a map from type variable id to target type.
     id_to_type = {}  # type: Dict[TypeVarId, Type]
     for i, tv in enumerate(tvars):
-        if types[i]:
-            id_to_type[tv.id] = types[i]
+        typ = types[i]
+        if typ:
+            id_to_type[tv.id] = typ
 
     # Apply arguments to argument types.
     arg_types = [expand_type(at, id_to_type) for at in callable.arg_types]

mypy/binder.py

@@ -212,7 +212,7 @@ def pop_frame(self, can_skip: bool, fall_through: int) -> Frame:
 
     def assign_type(self, expr: Expression,
                     type: Type,
-                    declared_type: Type,
+                    declared_type: Optional[Type],
                     restrict_any: bool = False) -> None:
         if not isinstance(expr, BindableTypes):
             return None

mypy/checker.py

@@ -630,7 +630,7 @@ class B(A): pass
 
     """
     if isinstance(method, Overloaded):
-        return cast(F, Overloaded([bind_self(c, method) for c in method.items()]))
+        return cast(F, Overloaded([bind_self(c, original_type) for c in method.items()]))
     assert isinstance(method, CallableType)
     func = method
     if not func.arg_types:

mypy/checkexpr.py

@@ -1,6 +1,6 @@
 """Type inference constraints."""
 
-from typing import Iterable, List, Optional
+from typing import Iterable, List, Optional, Sequence
 
 from mypy import experiments
 from mypy.types import (
@@ -42,7 +42,7 @@ def __repr__(self) -> str:
 
 
 def infer_constraints_for_callable(
-        callee: CallableType, arg_types: List[Optional[Type]], arg_kinds: List[int],
+        callee: CallableType, arg_types: Sequence[Optional[Type]], arg_kinds: List[int],
         formal_to_actual: List[List[int]]) -> List[Constraint]:
     """Infer type variable constraints for a callable and actual arguments.
 

mypy/checkmember.py

@@ -885,7 +885,8 @@ def visit_JoinedStr(self, n: ast3.JoinedStr) -> Expression:
             join_method.set_line(empty_string)
             result_expression = CallExpr(join_method,
                                          [strs_to_join],
-                                         [ARG_POS])
+                                         [ARG_POS],
+                                         [None])
             return result_expression
 
         # FormattedValue(expr value)
@@ -902,7 +903,8 @@ def visit_FormattedValue(self, n: ast3.FormattedValue) -> Expression:
             format_method.set_line(format_string)
             result_expression = CallExpr(format_method,
                                          [exp],
-                                         [ARG_POS])
+                                         [ARG_POS],
+                                         [None])
             return result_expression
 
     # Bytes(bytes s)

mypy/constraints.py

@@ -1,6 +1,6 @@
 """Utilities for type argument inference."""
 
-from typing import List, Optional
+from typing import List, Optional, Sequence
 
 from mypy.constraints import infer_constraints, infer_constraints_for_callable
 from mypy.types import Type, TypeVarId, CallableType
@@ -9,7 +9,7 @@
 
 
 def infer_function_type_arguments(callee_type: CallableType,
-                                  arg_types: List[Optional[Type]],
+                                  arg_types: Sequence[Optional[Type]],
                                   arg_kinds: List[int],
                                   formal_to_actual: List[List[int]],
                                   strict: bool = True) -> List[Optional[Type]]:

mypy/fastparse.py

@@ -165,7 +165,7 @@ def enable_errors(self) -> None:
     def is_errors(self) -> bool:
         return self.errors.is_errors()
 
-    def report(self, msg: str, context: Context, severity: str,
+    def report(self, msg: str, context: Optional[Context], severity: str,
                file: Optional[str] = None, origin: Optional[Context] = None,
                offset: int = 0) -> None:
         """Report an error or note (unless disabled)."""
@@ -175,7 +175,7 @@ def report(self, msg: str, context: Context, severity: str,
                                msg.strip(), severity=severity, file=file, offset=offset,
                                origin_line=origin.get_line() if origin else None)
 
-    def fail(self, msg: str, context: Context, file: Optional[str] = None,
+    def fail(self, msg: str, context: Optional[Context], file: Optional[str] = None,
              origin: Optional[Context] = None) -> None:
         """Report an error message (unless disabled)."""
         self.report(msg, context, 'error', file=file, origin=origin)
@@ -641,7 +641,7 @@ def invalid_index_type(self, index_type: Type, expected_type: Type, base_str: st
             self.format(index_type), base_str, self.format(expected_type)), context)
 
     def too_few_arguments(self, callee: CallableType, context: Context,
-                          argument_names: List[str]) -> None:
+                          argument_names: Optional[Sequence[Optional[str]]]) -> None:
         if (argument_names is not None and not all(k is None for k in argument_names)
                 and len(argument_names) >= 1):
             diff = [k for k in callee.arg_names if k not in argument_names]
@@ -695,7 +695,7 @@ def duplicate_argument_value(self, callee: CallableType, index: int,
                   format(capitalize(callable_name(callee)),
                          callee.arg_names[index]), context)
 
-    def does_not_return_value(self, callee_type: Type, context: Context) -> None:
+    def does_not_return_value(self, callee_type: Optional[Type], context: Context) -> None:
         """Report an error about use of an unusable type."""
         name = None  # type: Optional[str]
         if isinstance(callee_type, FunctionLike):

mypy/infer.py

@@ -112,7 +112,7 @@ def __init__(self, name: str, suite: 'Optional[Suite]' = None,
         self.name = name
         self.suite = suite
         self.old_cwd = None  # type: Optional[str]
-        self.tmpdir = None  # type: Optional[tempfile.TemporaryDirectory]
+        self.tmpdir = None  # type: Optional[tempfile.TemporaryDirectory[str]]
 
     def run(self) -> None:
         if self.func: