more tvdef -> tv

python · Aug 4, 2021 · ca294b4 · ca294b4
1 parent 591bcef
commit ca294b4
Show file tree

Hide file tree

Showing 2 changed files with 16 additions and 15 deletions.
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -3277,15 +3277,15 @@ def check_lst_expr(self, items: List[Expression], fullname: str,
         # Used for list and set expressions, as well as for tuples
         # containing star expressions that don't refer to a
         # Tuple. (Note: "lst" stands for list-set-tuple. :-)
-        tvdef = TypeVarType('T', 'T', -1, [], self.object_type())
+        tv = TypeVarType('T', 'T', -1, [], self.object_type())
         constructor = CallableType(
-            [tvdef],
+            [tv],
             [nodes.ARG_STAR],
             [None],
-            self.chk.named_generic_type(fullname, [tvdef]),
+            self.chk.named_generic_type(fullname, [tv]),
             self.named_type('builtins.function'),
             name=tag,
-            variables=[tvdef])
+            variables=[tv])
         out = self.check_call(constructor,
                               [(i.expr if isinstance(i, StarExpr) else i)
                                for i in items],
@@ -3434,22 +3434,22 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
                     tup.column = value.column
                 args.append(tup)
         # Define type variables (used in constructors below).
-        ktdef = TypeVarType('KT', 'KT', -1, [], self.object_type())
-        vtdef = TypeVarType('VT', 'VT', -2, [], self.object_type())
+        kt = TypeVarType('KT', 'KT', -1, [], self.object_type())
+        vt = TypeVarType('VT', 'VT', -2, [], self.object_type())
         rv = None
         # Call dict(*args), unless it's empty and stargs is not.
         if args or not stargs:
             # The callable type represents a function like this:
             #
             #   def <unnamed>(*v: Tuple[kt, vt]) -> Dict[kt, vt]: ...
             constructor = CallableType(
-                [TupleType([ktdef, vtdef], self.named_type('builtins.tuple'))],
+                [TupleType([kt, vt], self.named_type('builtins.tuple'))],
                 [nodes.ARG_STAR],
                 [None],
-                self.chk.named_generic_type('builtins.dict', [ktdef, vtdef]),
+                self.chk.named_generic_type('builtins.dict', [kt, vt]),
                 self.named_type('builtins.function'),
                 name='<dict>',
-                variables=[ktdef, vtdef])
+                variables=[kt, vt])
             rv = self.check_call(constructor, args, [nodes.ARG_POS] * len(args), e)[0]
         else:
             # dict(...) will be called below.
@@ -3460,13 +3460,13 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
             for arg in stargs:
                 if rv is None:
                     constructor = CallableType(
-                        [self.chk.named_generic_type('typing.Mapping', [ktdef, vtdef])],
+                        [self.chk.named_generic_type('typing.Mapping', [kt, vt])],
                         [nodes.ARG_POS],
                         [None],
-                        self.chk.named_generic_type('builtins.dict', [ktdef, vtdef]),
+                        self.chk.named_generic_type('builtins.dict', [kt, vt]),
                         self.named_type('builtins.function'),
                         name='<list>',
-                        variables=[ktdef, vtdef])
+                        variables=[kt, vt])
                     rv = self.check_call(constructor, [arg], [nodes.ARG_POS], arg)[0]
                 else:
                     self.check_method_call_by_name('update', rv, [arg], [nodes.ARG_POS], arg)
@@ -3756,16 +3756,16 @@ 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: List[Type] = [tvdef]
+            tv = TypeVarType('T', 'T', -1, [], self.object_type())
+            tv_list: List[Type] = [tv]
             constructor = CallableType(
                 tv_list,
                 [nodes.ARG_POS],
                 [None],
                 self.chk.named_generic_type(type_name, tv_list + additional_args),
                 self.chk.named_type('builtins.function'),
                 name=id_for_messages,
-                variables=[tvdef])
+                variables=[tv])
             return self.check_call(constructor,
                                 [gen.left_expr], [nodes.ARG_POS], gen)[0]
 

diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -8,6 +8,7 @@
     TypeAliasType, ParamSpecType
 )
 
+
 def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
     """Substitute any type variable references in a type given by a type
     environment.