Tighten code

python · JukkaL · Apr 21, 2017 · Apr 1, 2017 · Apr 1, 2017 · Apr 1, 2017
commit f46d52a9f8225ac4c84a866965f7a6542681c4c6
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -85,6 +85,7 @@
 from mypy.nodes import implicit_module_attrs
 from mypy.typeanal import (
     TypeAnalyser, TypeAnalyserPass3, analyze_type_alias, no_subscript_builtin_alias,
+    TypeVariableQuery,
 )
 from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError
 from mypy.sametypes import is_same_type
@@ -375,10 +376,8 @@ def update_function_type_variables(self, fun_type: CallableType, defn: Context)
         Update the signature of defn to contain type variable definitions
         if defn is generic.
         """
-
         a = self.type_analyzer(tvar_scope=TypeVarScope(self.tvar_scope))
-        variables = a.bind_function_type_variables(fun_type, defn)
-        fun_type.variables = variables
+        fun_type.variables = a.bind_function_type_variables(fun_type, defn)
 
     def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         # OverloadedFuncDef refers to any legitimate situation where you have
@@ -503,7 +502,6 @@ def analyze_function(self, defn: FuncItem) -> None:
             self.check_function_signature(defn)
             if isinstance(defn, FuncDef):
                 defn.type = set_callable_name(defn.type, defn)
-
         for arg in defn.arguments:
             if arg.initializer:
                 arg.initializer.accept(self)
@@ -556,12 +554,6 @@ def check_classvar_in_signature(self, typ: Type) -> None:
                 # Show only one error per signature
                 break
 
-    def type_var_names(self) -> Set[str]:
-        if not self.type:
-            return set()
-        else:
-            return set(self.type.type_vars)
-
     def check_function_signature(self, fdef: FuncItem) -> None:
         sig = fdef.type
         assert isinstance(sig, CallableType)
@@ -754,23 +746,8 @@ def get_all_bases_tvars(self, defn: ClassDef,
                 except TypeTranslationError:
                     # This error will be caught later.
                     continue
-                tvars.extend(self.get_tvars(base))
-        return self.remove_dups(tvars)
-
-    def get_tvars(self, tp: Type) -> List[Tuple[str, TypeVarExpr]]:
-        tvars = []  # type: List[Tuple[str, TypeVarExpr]]
-        if isinstance(tp, UnboundType):
-            tp_args = tp.args
-        elif isinstance(tp, TypeList):
-            tp_args = tp.items
-        else:
-            return tvars
-        for arg in tp_args:
-            tvar = self.analyze_unbound_tvar(arg)
-            if tvar:
-                tvars.append(tvar)
-            else:
-                tvars.extend(self.get_tvars(arg))
+                tvars.extend(base.accept(TypeVariableQuery(
+                    self.lookup_qualified, self.tvar_scope)))
         return self.remove_dups(tvars)
 
     def remove_dups(self, tvars: List[T]) -> List[T]:

diff --git a/mypy/tvar_scope.py b/mypy/tvar_scope.py
@@ -9,10 +9,9 @@ class TypeVarScope:
     def __init__(self, parent: Optional['TypeVarScope'] = None):
         self.scope = {}  # type: Dict[str, TypeVarDef]
         self.parent = parent
-        if parent is None:
-            self.func_id = 0
-            self.class_id = 0
-        else:
+        self.func_id = 0
+        self.class_id = 0
+        if parent is not None:
             self.func_id = parent.func_id
             self.class_id = parent.class_id
 
@@ -32,10 +31,7 @@ def _bind(self, name: str, tvar_expr: TypeVarExpr, i: int):
         self.scope[tvar_expr.fullname()] = tvar_def
 
     def get_binding(self, item: Union[str, SymbolTableNode]):
-        if isinstance(item, SymbolTableNode):
-            fullname = item.fullname
-        else:
-            fullname = item
+        fullname = item.fullname if isinstance(item, SymbolTableNode) else item
         if fullname in self.scope:
             return self.scope[fullname]
         elif self.parent is not None:
@@ -47,5 +43,4 @@ def __str__(self):
         me = ", ".join('{}: {}`{}'.format(k, v.name, v.id) for k, v in self.scope.items())
         if self.parent is None:
             return me
-        else:
-            return "{} <- {}".format(str(self.parent), me)
+        return "{} <- {}".format(str(self.parent), me)
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -131,7 +131,6 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                     not sym.normalized and not self.allow_unnormalized):
                 self.fail(no_subscript_builtin_alias(fullname), t)
             if sym.kind == TVAR and self.tvar_scope.get_binding(sym) is not None:
-                # XXX: Don't fetch twice
                 tvar_def = self.tvar_scope.get_binding(sym)
                 if len(t.args) > 0:
                     self.fail('Type variable &quo
8000
t;{}" used with arguments'.format(
@@ -259,7 +258,7 @@ def get_type_var_names(self, tp: Type) -> List[str]:
         """
         return [name for name, _
                 in tp.accept(TypeVariableQuery(self.lookup, self.tvar_scope,
-                                               include_callables=True,include_bound=True))]
+                                               include_callables=True, include_bound=True))]
 
     def get_tvar_name(self, t: Type) -> Optional[str]:
         if not isinstance(t, UnboundType):
@@ -411,11 +410,12 @@ def infer_type_variables(self,
         names = []  # type: List[str]
         tvars = []  # type: List[TypeVarExpr]
         for arg in type.arg_types:
-            for name, tvar_expr in self.find_type_variables_in_type(arg, include_callables=True):
+            for name, tvar_expr in arg.accept(TypeVariableQuery(self.lookup, self.tvar_scope)):
                 if name not in names:
                     names.append(name)
                     tvars.append(tvar_expr)
-        for name, tvar_expr in self.find_type_variables_in_type(type.ret_type, include_callables=False):
+        for name, tvar_expr in type.ret_type.accept(
+                TypeVariableQuery(self.lookup, self.tvar_scope, include_callables=False)):
             if name not in names:
                 names.append(name)
                 tvars.append(tvar_expr)
@@ -441,10 +441,6 @@ def bind_function_type_variables(self, fun_type: CallableType, defn: Context) ->
     def is_defined_type_var(self, tvar: str, context: Context) -> bool:
         return self.tvar_scope.get_binding(self.lookup(tvar, context)) is not None
 
-    def find_type_variables_in_type(self, type: Type, *, include_callables: bool) -> List[Tuple[str, TypeVarExpr]]:
-        ret = type.accept(TypeVariableQuery(self.lookup, self.tvar_scope, include_callables))
-        return ret
-
     def anal_array(self, a: List[Type], nested: bool = True) -> List[Type]:
         res = []  # type: List[Type]
         for t in a:
@@ -619,8 +615,8 @@ class TypeVariableQuery(TypeQuery[TypeVarList]):
     def __init__(self,
                  lookup: Callable[[str, Context], SymbolTableNode],
             
4F4B
     scope: 'TypeVarScope',
-                 include_callables: bool,
                  *,
+                 include_callables: bool = True,
                  include_bound: bool = False):
         self.include_callables = include_callables
         self.lookup = lookup