[clean-strict-optional] Clean-up the type checking files

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/checkmember.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/constraints.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/fastparse.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/infer.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/messages.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/myunit/__init__.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:

mypy/nodes.py

@@ -1241,7 +1241,7 @@ def __init__(self,
                  callee: Expression,
                  args: List[Expression],
                  arg_kinds: List[int],
-                 arg_names: Optional[List[Optional[str]]] = None,
+                 arg_names: List[Optional[str]],
                  analyzed: Optional[Expression] = None) -> None:
         if not arg_names:
             arg_names = [None] * len(args)
@@ -1731,13 +1731,13 @@ class TypeAliasExpr(Expression):
     type = None  # type: mypy.types.Type
     # Simple fallback type for aliases that are invalid in runtime expressions
     # (for example Union, Tuple, Callable).
-    fallback = None  # type: Optional[mypy.types.Type]
+    fallback = None  # type: mypy.types.Type
     # This type alias is subscripted in a runtime expression like Alias[int](42)
     # (not in a type context like type annotation or base class).
     in_runtime = False  # type: bool
 
     def __init__(self, type: 'mypy.types.Type', tvars: List[str],
-                 fallback: 'Optional[mypy.types.Type]' = None, in_runtime: bool = False) -> None:
+                 fallback: 'mypy.types.Type', in_runtime: bool = False) -> None:
         self.type = type
         self.fallback = fallback
         self.in_runtime = in_runtime

mypy/types.py

@@ -1011,7 +1011,8 @@ def copy_modified(self, *, fallback: Optional[Instance] = None,
             items = self.items
         return TupleType(items, fallback, self.line, self.column)
 
-    def slice(self, begin: int, stride: int, end: int) -> 'TupleType':
+    def slice(self, begin: Optional[int], stride: Optional[int],
+              end: Optional[int]) -> 'TupleType':
         return TupleType(self.items[begin:end:stride], self.fallback,
                          self.line, self.column, self.implicit)
 

mypy_self_check.ini

@@ -8,21 +8,6 @@ disallow_any = generics, unimported
 warn_redundant_casts = True
 warn_unused_ignores = True
 
-; historical exceptions
-[mypy-mypy.binder]
-disallow_any = unimported
-
-[mypy-mypy.checker]
-strict_optional = False
-
-[mypy-mypy.checkexpr]
-strict_optional = False
-
+# historical exception
 [mypy-mypy.semanal]
 strict_optional = False
-
-[mypy-mypy.myunit]
-disallow_any = unimported
-
-[mypy-mypy.nodes]
-disallow_any = unimported