anal: generalise TypeVarList, TypeVariableQuery

Author: hauntsaninja

mypy/semanal.py

@@ -97,7 +97,7 @@
 from mypy.nodes import implicit_module_attrs
 from mypy.typeanal import (
     TypeAnalyser, analyze_type_alias, no_subscript_builtin_alias,
-    TypeVariableQuery, TypeVarList, remove_dups, has_any_from_unimported_type,
+    TypeVarLikeQuery, TypeVarLikeList, remove_dups, has_any_from_unimported_type,
     check_for_explicit_any, type_constructors, fix_instance_types
 )
 from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError
@@ -1212,7 +1212,7 @@ class Foo(Bar, Generic[T]): ...
         Returns (remaining base expressions, inferred type variables, is protocol).
         """
         removed = []  # type: List[int]
-        declared_tvars = []  # type: TypeVarList
+        declared_tvars = []  # type: TypeVarLikeList
         is_protocol = False
         for i, base_expr in enumerate(base_type_exprs):
             self.analyze_type_expr(base_expr)
@@ -1266,7 +1266,7 @@ class Foo(Bar, Generic[T]): ...
             tvar_defs.append(tvar_def)
         return base_type_exprs, tvar_defs, is_protocol
 
-    def analyze_class_typevar_declaration(self, base: Type) -> Optional[Tuple[TypeVarList, bool]]:
+    def analyze_class_typevar_declaration(self, base: Type) -> Optional[Tuple[TypeVarLikeList, bool]]:
         """Analyze type variables declared using Generic[...] or Protocol[...].
 
         Args:
@@ -1285,7 +1285,7 @@ def analyze_class_typevar_declaration(self, base: Type) -> Optional[Tuple[TypeVa
                 sym.node.fullname == 'typing.Protocol' and base.args or
                 sym.node.fullname == 'typing_extensions.Protocol' and base.args):
             is_proto = sym.node.fullname != 'typing.Generic'
-            tvars = []  # type: TypeVarList
+            tvars = []  # type: TypeVarLikeList
             for arg in unbound.args:
                 tag = self.track_incomplete_refs()
                 tvar = self.analyze_unbound_tvar(arg)
@@ -1315,17 +1315,17 @@ def analyze_unbound_tvar(self, t: Type) -> Optional[Tuple[str, TypeVarExpr]]:
 
     def get_all_bases_tvars(self,
                             base_type_exprs: List[Expression],
-                            removed: List[int]) -> TypeVarList:
+                            removed: List[int]) -> TypeVarLikeList:
         """Return all type variable references in bases."""
-        tvars = []  # type: TypeVarList
+        tvars = []  # type: TypeVarLikeList
         for i, base_expr in enumerate(base_type_exprs):
             if i not in removed:
                 try:
                     base = expr_to_unanalyzed_type(base_expr)
                 except TypeTranslationError:
                     # This error will be caught later.
                     continue
-                base_tvars = base.accept(TypeVariableQuery(self.lookup_qualified, self.tvar_scope))
+                base_tvars = base.accept(TypeVarLikeQuery(self.lookup_qualified, self.tvar_scope))
                 tvars.extend(base_tvars)
         return remove_dups(tvars)
 
@@ -2419,7 +2419,7 @@ def analyze_alias(self, rvalue: Expression,
         typ = None  # type: Optional[Type]
         if res:
             typ, depends_on = res
-            found_type_vars = typ.accept(TypeVariableQuery(self.lookup_qualified, self.tvar_scope))
+            found_type_vars = typ.accept(TypeVarLikeQuery(self.lookup_qualified, self.tvar_scope))
             alias_tvars = [name for (name, node) in found_type_vars]
             qualified_tvars = [node.fullname for (name, node) in found_type_vars]
         else:

mypy/typeanal.py

@@ -22,7 +22,7 @@
 from mypy.nodes import (
     TypeInfo, Context, SymbolTableNode, Var, Expression,
     nongen_builtins, check_arg_names, check_arg_kinds, ARG_POS, ARG_NAMED,
-    ARG_OPT, ARG_NAMED_OPT, ARG_STAR, ARG_STAR2, TypeVarExpr,
+    ARG_OPT, ARG_NAMED_OPT, ARG_STAR, ARG_STAR2, TypeVarExpr, TypeVarLikeExpr,
     TypeAlias, PlaceholderNode, SYMBOL_FUNCBASE_TYPES, Decorator, MypyFile
 )
 from mypy.typetraverser import TypeTraverserVisitor
@@ -792,13 +792,14 @@ def tvar_scope_frame(self) -> Iterator[None]:
         self.tvar_scope = old_scope
 
     def infer_type_variables(self,
-                             type: CallableType) -> List[Tuple[str, TypeVarExpr]]:
+                             type: CallableType) -> List[Tuple[str, TypeVarLikeExpr]]:
         """Return list of unique type variables referred to in a callable."""
         names = []  # type: List[str]
-        tvars = []  # type: List[TypeVarExpr]
+        tvars = []  # type: List[TypeVarLikeExpr]
         for arg in type.arg_types:
-            for name, tvar_expr in arg.accept(TypeVariableQuery(self.lookup_qualified,
-                                                                self.tvar_scope)):
+            for name, tvar_expr in arg.accept(
+                TypeVarLikeQuery(self.lookup_qualified, self.tvar_scope)
+            ):
                 if name not in names:
                     names.append(name)
                     tvars.append(tvar_expr)
@@ -807,8 +808,8 @@ def infer_type_variables(self,
         # functions in the return type belong to those functions, not the
         # function we're currently analyzing.
         for name, tvar_expr in type.ret_type.accept(
-                TypeVariableQuery(self.lookup_qualified, self.tvar_scope,
-                                  include_callables=False)):
+            TypeVarLikeQuery(self.lookup_qualified, self.tvar_scope, include_callables=False)
+        ):
             if name not in names:
                 names.append(name)
                 tvars.append(tvar_expr)
@@ -905,7 +906,7 @@ def tuple_type(self, items: List[Type]) -> TupleType:
         return TupleType(items, fallback=self.named_type('builtins.tuple', [any_type]))
 
 
-TypeVarList = List[Tuple[str, TypeVarExpr]]
+TypeVarLikeList = List[Tuple[str, TypeVarLikeExpr]]
 
 # Mypyc doesn't support callback protocols yet.
 MsgCallback = Callable[[str, Context, DefaultNamedArg(Optional[ErrorCode], 'code')], None]
@@ -1066,7 +1067,7 @@ def flatten_tvars(ll: Iterable[List[T]]) -> List[T]:
     return remove_dups(chain.from_iterable(ll))
 
 
-class TypeVariableQuery(TypeQuery[TypeVarList]):
+class TypeVarLikeQuery(TypeQuery[TypeVarLikeList]):
 
     def __init__(self,
                  lookup: Callable[[str, Context], Optional[SymbolTableNode]],
@@ -1087,12 +1088,12 @@ def _seems_like_callable(self, type: UnboundType) -> bool:
             return True
         return False
 
-    def visit_unbound_type(self, t: UnboundType) -> TypeVarList:
+    def visit_unbound_type(self, t: UnboundType) -> TypeVarLikeList:
         name = t.name
         node = self.lookup(name, t)
-        if node and isinstance(node.node, TypeVarExpr) and (
+        if node and isinstance(node.node, TypeVarLikeExpr) and (
                 self.include_bound_tvars or self.scope.get_binding(node) is None):
-            assert isinstance(node.node, TypeVarExpr)
+            assert isinstance(node.node, TypeVarLikeExpr)
             return [(name, node.node)]
         elif not self.include_callables and self._seems_like_callable(t):
             return []
@@ -1101,7 +1102,7 @@ def visit_unbound_type(self, t: UnboundType) -> TypeVarList:
         else:
             return super().visit_unbound_type(t)
 
-    def visit_callable_type(self, t: CallableType) -> TypeVarList:
+    def visit_callable_type(self, t: CallableType) -> TypeVarLikeList:
         if self.include_callables:
             return super().visit_callable_type(t)
         else: