Merge remote-tracking branch 'upstream/master' into typevar2

python · hauntsaninja · Aug 4, 2021 · Jan 19, 2021 · Jan 19, 2021 · Jan 19, 2021
commit 4e82ce9e24ad56cbb2bd708b7de30d26f49b5110
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -3757,7 +3757,7 @@ def check_generator_or_comprehension(self, gen: GeneratorExpr,
             # Infer the type of the list comprehension by using a synthetic generic
             # callable type.
             tvdef = TypeVarType('T', 'T', -1, [], self.object_type())
-            tv_list = [tvdef]  # type: List[Type]
+            tv_list: List[Type] = [tvdef]
             constructor = CallableType(
                 tv_list,
                 [nodes.ARG_POS],
@@ -4462,10 +4462,9 @@ def merge_typevars_in_callables_by_name(
 
     Returns both the new list of callables and a list of all distinct TypeVarType objects used.
     """
-
-    output = []  # type: List[CallableType]
-    unique_typevars = {}  # type: Dict[str, TypeVarType]
-    variables = []  # type: List[TypeVarType]
+    output: List[CallableType] = []
+    unique_typevars: Dict[str, TypeVarType] = {}
+    variables: List[TypeVarType] = []
 
     for target in callables:
         if target.is_generic():

diff --git a/mypy/nodes.py b/mypy/nodes.py
@@ -921,11 +921,10 @@ def deserialize(cls, data: JsonDict) -> 'Var':
 
 class ClassDef(Statement):
     """Class definition"""
-
-    name = None  # type: str       # Name of the class without module prefix
-    fullname = None  # type: Bogus[str]   # Fully qualified name of the class
-    defs = None  # type: Block
-    type_vars = None  # type: List[mypy.types.TypeVarType]
+    name: str  # Name of the class without module prefix
+    fullname: Bogus[str] = None  # type: ignore # Fully qualified name of the class
+    defs: "Block"
+    type_vars: List["mypy.types.TypeVarType"]
     # Base class expressions (not semantically analyzed -- can be arbitrary expressions)
     base_type_exprs: List[Expression]
     # Special base classes like Generic[...] get moved here during semantic analysis

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
@@ -13,7 +13,7 @@
     add_method, _get_decorator_bool_argument, deserialize_and_fixup_type,
 )
 from mypy.typeops import map_type_from_supertype
-from mypy.types import Type, Instance, NoneType, TypeVarType, get_proper_type
+from mypy.types import Type, Instance, NoneType, TypeVarType, CallableType, get_proper_type
 from mypy.server.trigger import make_wildcard_trigger
 
 # The set of decorators that generate dataclasses.

diff --git a/mypy/plugins/default.py b/mypy/plugins/default.py
@@ -9,8 +9,8 @@
 )
 from mypy.plugins.common import try_getting_str_literals
 from mypy.types import (
-    Type, Instance, AnyType, TypeOfAny, CallableType, NoneType, TypedDictType,
-    TypeVarType, TypeVarType, TPDICT_FB_NAMES, get_proper_type, LiteralType
+    FunctionLike, Type, Instance, AnyType, TypeOfAny, CallableType, NoneType, TypedDictType,
+    TypeVarType, TPDICT_FB_NAMES, get_proper_type, LiteralType
 )
 from mypy.subtypes import is_subtype
 from mypy.typeops import make_simplified_union

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -1314,7 +1314,7 @@ class Foo(Bar, Generic[T]): ...
             # grained incremental mode.
             defn.removed_base_type_exprs.append(defn.base_type_exprs[i])
             del base_ty
ED4F
pe_exprs[i]
-        tvar_defs = []  # type: List[TypeVarType]
+        tvar_defs: List[TypeVarType] = []
         for name, tvar_expr in declared_tvars:
             tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
             assert isinstance(tvar_def, TypeVarType), (

diff --git a/mypy/server/astmerge.py b/mypy/server/astmerge.py
@@ -57,9 +57,9 @@
 from mypy.traverser import TraverserVisitor
 from mypy.types import (
     Type, SyntheticTypeVisitor, Instance, AnyType, NoneType, CallableType, ErasedType, DeletedType,
-    TupleType, TypeType, TypedDictType, UnboundType, UninhabitedType, UnionType,
+    TupleType, TypeType, TypeVarType, TypedDictType, UnboundType, UninhabitedType, UnionType,
     Overloaded, TypeVarType, TypeList, CallableArgument, EllipsisType, StarType, LiteralType,
-    RawExpressionType, PartialType, PlaceholderType, TypeAliasType
+    RawExpressionType, PartialType, PlaceholderType, TypeAliasType, TypeGuardType
 )
 from mypy.util import get_prefix, replace_object_state
 from mypy.typestate import TypeState

diff --git a/mypy/test/testtypes.py b/mypy/test/testtypes.py
@@ -11,8 +11,7 @@
 from mypy.indirection import TypeIndirectionVisitor
 from mypy.types import (
     UnboundType, AnyType, CallableType, TupleType, TypeVarType, Type, Instance, NoneType,
-    Overloaded, TypeType, UnionType, UninhabitedType, TypeVarId, TypeOfAny,
-    LiteralType, get_proper_type
+    Overloaded, TypeType, UnionType, UninhabitedType, TypeVarId, TypeOfAny, get_proper_type
 )
 from mypy.nodes import ARG_POS, ARG_OPT, ARG_STAR, ARG_STAR2, CONTRAVARIANT, INVARIANT, COVARIANT
 from mypy.subtypes import is_subtype, is_more_precise, is_proper_subtype
@@ -495,7 +494,7 @@ def callable(self, vars: List[str], *a: Type) -> CallableType:
         argument types a1, ... an and return type r and type arguments
         vars.
         """
-        tv = []  # type: List[TypeVarType]
+        tv: List[TypeVarType] = []
         n = -1
         for v in vars:
             tv.append(TypeVarType(v, v, n, [], self.fx.o))

diff --git a/mypy/test/typefixture.py b/mypy/test/typefixture.py
@@ -6,8 +6,8 @@
 from typing import List, Optional, Tuple
 
 from mypy.types import (
-    Type, AnyType, NoneType, Instance, CallableType, TypeVarType, TypeType,
-    UninhabitedType, TypeOfAny, TypeAliasType, UnionType
+    Type, TypeVarType, AnyType, NoneType, Instance, CallableType, TypeVarType, TypeType,
+    UninhabitedType, TypeOfAny, TypeAliasType, UnionType, LiteralType
 )
 from mypy.nodes import (
     TypeInfo, ClassDef, Block, ARG_POS, ARG_OPT, ARG_STAR, SymbolTable,
@@ -223,7 +223,7 @@ def make_type_info(self, name: str,
                 module_name = '__main__'
 
         if typevars:
-            v = []  # type: List[TypeVarType]
+            v: List[TypeVarType] = []
             for id, n in enumerate(typevars, 1):
                 if variances:
                     variance = variances[id - 1]

diff --git a/mypy/tvar_scope.py b/mypy/tvar_scope.py
@@ -21,7 +21,7 @@ def __init__(self,
           prohibited: Type variables that aren't strictly in scope exactly,
                       but can't be bound because they're part of an outer class's scope.
         """
-        self.scope = {}  # type: Dict[str, TypeVarLikeType]
+        self.scope: Dict[str, TypeVarLikeType] = {}
         self.parent = parent
         self.func_id = 0
         self.class_id = 0
@@ -63,7 +63,7 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
             self.func_id -= 1
             i = self.func_id
         if isinstance(tvar_expr, TypeVarExpr):
-            tvar_def = TypeVarType(
+            tvar_def: TypeVarLikeType = TypeVarType(
                 name,
                 tvar_expr.fullname,
                 i,
@@ -72,7 +72,7 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
                 variance=tvar_expr.variance,
                 line=tvar_expr.line,
                 column=tvar_expr.column
-            )  # type: TypeVarLikeType
+            )
         elif isinstance(tvar_expr, ParamSpecExpr):
             tvar_def = ParamSpecType(
                 name,

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -13,8 +13,8 @@
 from mypy.options import Options
 from mypy.types import (
     Type, UnboundType, TypeVarType, TupleType, TypedDictType, UnionType, Instance, AnyType,
-    CallableType, NoneType, ErasedType, DeletedType, TypeList, SyntheticTypeVisitor,
-    StarType, PartialType, EllipsisType, UninhabitedType, TypeType,
+    CallableType, NoneType, ErasedType, DeletedType, TypeList, TypeVarType, SyntheticTypeVisitor,
+    StarType, PartialType, EllipsisType, UninhabitedType, TypeType, TypeGuardType, TypeVarLikeType,
     CallableArgument, TypeQuery, union_items, TypeOfAny, LiteralType, RawExpressionType,
     PlaceholderType, Overloaded, get_proper_type, TypeAliasType, TypeVarLikeType, ParamSpecType
 )
@@ -938,7 +938,7 @@ def bind_function_type_variables(
         # Do not define a new type variable if already defined in scope.
         typevars = [(name, tvar) for name, tvar in typevars
                     if not self.is_defined_type_var(name, defn)]
-        defs = []  # type: List[TypeVarLikeType]
+        defs: List[TypeVarLikeType] = []
         for name, tvar in typevars:
             if not self.tvar_scope.allow_binding(tvar.fullname):
                 self.fail('Type variable "{}" is bound by an outer class'.format(name), defn)

diff --git a/mypy/typeops.py b/mypy/typeops.py
@@ -113,7 +113,7 @@ def class_callable(init_type: CallableType, info: TypeInfo, type_type: Instance,
                    special_sig: Optional[str],
                    is_new: bool, orig_self_type: Optional[Type] = None) -> CallableType:
     """Create a type object type based on the signature of __init__."""
-    variables = []  # type: List[TypeVarLikeType]
+    variables: List[TypeVarLikeType] = []
     variables.extend(info.defn.type_vars)
     variables.extend(init_type.variables)
 
@@ -228,7 +228,7 @@ class B(A): pass
         return cast(F, func)
     self_param_type = get_proper_type(func.arg_types[0])
 
-    variables = []  # type: Sequence[TypeVarLikeType]
+    variables: Sequence[TypeVarLikeType] = []
     if func.variables and supported_self_type(self_param_type):
         if original_type is None:
             # TODO: type check method override (see #7861).

diff --git a/mypy/types.py b/mypy/types.py
@@ -915,7 +915,6 @@ def copy_modified(self, *,
     def has_readable_member(self, name: str) -> bool:
         return self.type.has_readable_member(name)
 
-
 class FunctionLike(ProperType):
     """Abstract base class for function types."""
 

diff --git a/mypy/typevars.py b/mypy/typevars.py
@@ -11,7 +11,7 @@ def fill_typevars(typ: TypeInfo) -> Union[Instance, TupleType]:
 
     For a generic G type with parameters T1, .., Tn, return G[T1, ..., Tn].
     """
-    tvs = []  # type: List[Type]
+    tvs: List[Type] = []
     # TODO: why do we need to keep both typ.type_vars and typ.defn.type_vars?
     for i in range(len(typ.defn.type_vars)):
         tv = typ.defn.type_vars[i]