typevarlikedef -> typevarliketype

Author: hauntsaninja

mypy/applytype.py

@@ -5,13 +5,13 @@
 from mypy.expandtype import expand_type
 from mypy.types import (
     Type, TypeVarId, TypeVarType, CallableType, AnyType, PartialType, get_proper_types,
-    TypeVarLikeDef, ProperType
+    TypeVarLikeType, ProperType
 )
 from mypy.nodes import Context
 
 
 def get_target_type(
-    tvar: TypeVarLikeDef,
+    tvar: TypeVarLikeType,
     type: ProperType,
     callable: CallableType,
     report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],

mypy/checkmember.py

@@ -5,7 +5,7 @@
 
 from mypy.types import (
     Type, Instance, AnyType, TupleType, TypedDictType, CallableType, FunctionLike,
-    TypeVarLikeDef, Overloaded, TypeVarType, UnionType, PartialType, TypeOfAny, LiteralType,
+    TypeVarLikeType, Overloaded, TypeVarType, UnionType, PartialType, TypeOfAny, LiteralType,
     DeletedType, NoneType, TypeType, has_type_vars, get_proper_type, ProperType
 )
 from mypy.nodes import (
@@ -679,7 +679,7 @@ def analyze_class_attribute_access(itype: Instance,
                                    name: str,
                                    mx: MemberContext,
                                    override_info: Optional[TypeInfo] = None,
-                                   original_vars: Optional[Sequence[TypeVarLikeDef]] = None
+                                   original_vars: Optional[Sequence[TypeVarLikeType]] = None
                                    ) -> Optional[Type]:
     """Analyze access to an attribute on a class object.
 
@@ -842,7 +842,7 @@ def analyze_enum_class_attribute_access(itype: Instance,
 def add_class_tvars(t: ProperType, isuper: Optional[Instance],
                     is_classmethod: bool,
                     original_type: Type,
-                    original_vars: Optional[Sequence[TypeVarLikeDef]] = None) -> Type:
+                    original_vars: Optional[Sequence[TypeVarLikeType]] = None) -> Type:
     """Instantiate type variables during analyze_class_attribute_access,
     e.g T and Q in the following:
 

mypy/messages.py

@@ -1876,7 +1876,7 @@ def [T <: int] f(self, x: int, y: T) -> None
                 else:
                     tvars.append(tvar.name)
             else:
-                # For other TypeVarLikeDefs, just use the repr
+                # For other TypeVarLikeTypes, just use the repr
                 tvars.append(repr(tvar))
         s = '[{}] {}'.format(', '.join(tvars), s)
     return 'def {}'.format(s)

mypy/tvar_scope.py

@@ -1,12 +1,12 @@
 from typing import Optional, Dict, Union
-from mypy.types import TypeVarLikeDef, TypeVarType, ParamSpecDef
+from mypy.types import TypeVarLikeType, TypeVarType, ParamSpecDef
 from mypy.nodes import ParamSpecExpr, TypeVarExpr, TypeVarLikeExpr, SymbolTableNode
 
 
 class TypeVarLikeScope:
     """Scope that holds bindings for type variables and parameter specifications.
 
-    Node fullname -> TypeVarLikeDef.
+    Node fullname -> TypeVarLikeType.
     """
 
     def __init__(self,
@@ -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, TypeVarLikeDef]
+        self.scope = {}  # type: Dict[str, TypeVarLikeType]
         self.parent = parent
         self.func_id = 0
         self.class_id = 0
@@ -55,7 +55,7 @@ def class_frame(self) -> 'TypeVarLikeScope':
         """A new scope frame for binding a class. Prohibits *this* class's tvars"""
         return TypeVarLikeScope(self.get_function_scope(), True, self)
 
-    def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeDef:
+    def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
         if self.is_class_scope:
             self.class_id += 1
             i = self.class_id
@@ -72,7 +72,7 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeDef:
                 variance=tvar_expr.variance,
                 line=tvar_expr.line,
                 column=tvar_expr.column
-            )  # type: TypeVarLikeDef
+            )  # type: TypeVarLikeType
         elif isinstance(tvar_expr, ParamSpecExpr):
             tvar_def = ParamSpecDef(
                 name,
@@ -86,10 +86,10 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeDef:
         self.scope[tvar_expr.fullname] = tvar_def
         return tvar_def
 
-    def bind_existing(self, tvar_def: TypeVarLikeDef) -> None:
+    def bind_existing(self, tvar_def: TypeVarLikeType) -> None:
         self.scope[tvar_def.fullname] = tvar_def
 
-    def get_binding(self, item: Union[str, SymbolTableNode]) -> Optional[TypeVarLikeDef]:
+    def get_binding(self, item: Union[str, SymbolTableNode]) -> Optional[TypeVarLikeType]:
         fullname = item.fullname if isinstance(item, SymbolTableNode) else item
         assert fullname is not None
         if fullname in self.scope:

mypy/type_visitor.py

@@ -21,7 +21,7 @@
 from mypy.types import (
     Type, AnyType, CallableType, Overloaded, TupleType, TypedDictType, LiteralType,
     RawExpressionType, Instance, NoneType, TypeType,
-    UnionType, TypeVarType, PartialType, DeletedType, UninhabitedType, TypeVarLikeDef,
+    UnionType, TypeVarType, PartialType, DeletedType, UninhabitedType, TypeVarLikeType,
     UnboundType, ErasedType, StarType, EllipsisType, TypeList, CallableArgument,
     PlaceholderType, TypeAliasType, get_proper_type
 )
@@ -221,7 +221,7 @@ def translate_types(self, types: Iterable[Type]) -> List[Type]:
         return [t.accept(self) for t in types]
 
     def translate_variables(self,
-                            variables: Sequence[TypeVarLikeDef]) -> Sequence[TypeVarLikeDef]:
+                            variables: Sequence[TypeVarLikeType]) -> Sequence[TypeVarLikeType]:
         return variables
 
     def visit_overloaded(self, t: Overloaded) -> Type:

mypy/typeanal.py

@@ -16,7 +16,7 @@
     CallableType, NoneType, ErasedType, DeletedType, TypeList, SyntheticTypeVisitor,
     StarType, PartialType, EllipsisType, UninhabitedType, TypeType,
     CallableArgument, TypeQuery, union_items, TypeOfAny, LiteralType, RawExpressionType,
-    PlaceholderType, Overloaded, get_proper_type, TypeAliasType, TypeVarLikeDef, ParamSpecDef
+    PlaceholderType, Overloaded, get_proper_type, TypeAliasType, TypeVarLikeType, ParamSpecDef
 )
 
 from mypy.nodes import (
@@ -917,7 +917,7 @@ def infer_type_variables(self,
 
     def bind_function_type_variables(
         self, fun_type: CallableType, defn: Context
-    ) -> Sequence[TypeVarLikeDef]:
+    ) -> Sequence[TypeVarLikeType]:
         """Find the type variables of the function type and bind them in our tvar_scope"""
         if fun_type.variables:
             for var in fun_type.variables:
@@ -931,7 +931,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[TypeVarLikeDef]
+        defs = []  # type: 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)
@@ -963,7 +963,7 @@ def anal_type(self, t: Type, nested: bool = True) -> Type:
             if nested:
                 self.nesting_level -= 1
 
-    def anal_var_def(self, var_def: TypeVarLikeDef) -> TypeVarLikeDef:
+    def anal_var_def(self, var_def: TypeVarLikeType) -> TypeVarLikeType:
         if isinstance(var_def, TypeVarType):
             return TypeVarType(
                 var_def.name,
@@ -977,7 +977,7 @@ def anal_var_def(self, var_def: TypeVarLikeDef) -> TypeVarLikeDef:
         else:
             return var_def
 
-    def anal_var_defs(self, var_defs: Sequence[TypeVarLikeDef]) -> List[TypeVarLikeDef]:
+    def anal_var_defs(self, var_defs: Sequence[TypeVarLikeType]) -> List[TypeVarLikeType]:
         return [self.anal_var_def(vd) for vd in var_defs]
 
     def named_type_with_normalized_str(self, fully_qualified_name: str) -> Instance:

mypy/typeops.py

@@ -10,7 +10,7 @@
 import sys
 
 from mypy.types import (
-    TupleType, Instance, FunctionLike, Type, CallableType, TypeVarLikeDef, Overloaded,
+    TupleType, Instance, FunctionLike, Type, CallableType, TypeVarLikeType, Overloaded,
     TypeVarType, UninhabitedType, FormalArgument, UnionType, NoneType, TypedDictType,
     AnyType, TypeOfAny, TypeType, ProperType, LiteralType, get_proper_type, get_proper_types,
     copy_type, TypeAliasType, TypeQuery
@@ -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[TypeVarLikeDef]
+    variables = []  # type: 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[TypeVarLikeDef]
+    variables = []  # type: Sequence[TypeVarLikeType]
     if func.variables and supported_self_type(self_param_type):
         if original_type is None:
             # TODO: type check method override (see #7861).
@@ -474,7 +474,7 @@ def true_or_false(t: Type) -> ProperType:
     return new_t
 
 
-def erase_def_to_union_or_bound(tdef: TypeVarLikeDef) -> Type:
+def erase_def_to_union_or_bound(tdef: TypeVarLikeType) -> Type:
     # TODO(shantanu): fix for ParamSpecDef
     assert isinstance(tdef, TypeVarType)
     if tdef.values:

mypy/types.py

@@ -338,7 +338,7 @@ def is_meta_var(self) -> bool:
         return self.meta_level > 0
 
 
-class TypeVarLikeDef(ProperType):
+class TypeVarLikeType(ProperType):
     name = ''  # Name (may be qualified)
     fullname = ''  # Fully qualified name
     id = None  # type: TypeVarId
@@ -357,11 +357,11 @@ def serialize(self) -> JsonDict:
         raise NotImplementedError
 
     @classmethod
-    def deserialize(cls, data: JsonDict) -> 'TypeVarLikeDef':
+    def deserialize(cls, data: JsonDict) -> 'TypeVarLikeType':
         raise NotImplementedError
 
 
-class TypeVarType(TypeVarLikeDef):
+class TypeVarType(TypeVarLikeType):
     """Definition of a single type variable."""
     values = None  # type: List[Type]  # Value restriction, empty list if no restriction
     upper_bound = None  # type: Type
@@ -417,7 +417,7 @@ def deserialize(cls, data: JsonDict) -> 'TypeVarType':
         )
 
 
-class ParamSpecDef(TypeVarLikeDef):
+class ParamSpecDef(TypeVarLikeType):
     """Definition of a single ParamSpec variable."""
 
     def __repr__(self) -> str:
@@ -975,7 +975,7 @@ def __init__(self,
                  fallback: Instance,
                  name: Optional[str] = None,
                  definition: Optional[SymbolNode] = None,
-                 variables: Optional[Sequence[TypeVarLikeDef]] = None,
+                 variables: Optional[Sequence[TypeVarLikeType]] = None,
                  line: int = -1,
                  column: int = -1,
                  is_ellipsis_args: bool = False,
@@ -1029,7 +1029,7 @@ def copy_modified(self,
                       fallback: Bogus[Instance] = _dummy,
                       name: Bogus[Optional[str]] = _dummy,
                       definition: Bogus[SymbolNode] = _dummy,
-                      variables: Bogus[Sequence[TypeVarLikeDef]] = _dummy,
+                      variables: Bogus[Sequence[TypeVarLikeType]] = _dummy,
                       line: Bogus[int] = _dummy,
                       column: Bogus[int] = _dummy,
                       is_ellipsis_args: Bogus[bool] = _dummy,
@@ -2085,7 +2085,7 @@ def visit_callable_type(self, t: CallableType) -> str:
                     else:
                         vs.append(var.name)
                 else:
-                    # For other TypeVarLikeDefs, just use the repr
+                    # For other TypeVarLikeTypes, just use the repr
                     vs.append(repr(var))
             s = '{} {}'.format('[{}]'.format(', '.join(vs)), s)