Move the typevars that are prohibited due to being bound by the class…

… into TypeVarScope This allows us to be more consistent about which type variables we allow and which we don't.
python · JukkaL · Apr 21, 2017 · Apr 1, 2017 · Apr 1, 2017 · Apr 1, 2017
commit 21d8b138dc0890e5ea29ad77b5aab6b6b688fdea
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -189,10 +189,6 @@ class SemanticAnalyzer(NodeVisitor):
     bound_tvars = None  # type: List[SymbolTableNode]
     # Type variables bound by the current scope, be it class or function
     tvar_scope = None  # type: TypeVarScope
-    # Type variables bound by current function/method
-    function_tvar_scope = None  # type: TypeVarScope
-    # Stack of type variable scopes bound by current class. Only the last is active.
-    classdef_tvar_scopes = None  # type: List[TypeVarScope]
     # Per-module options
     options = None  # type: Options
 
@@ -227,8 +223,6 @@ def __init__(self,
         self.type = None
         self.type_stack = []
         self.tvar_scope = TypeVarScope()
-        self.function_tvar_scope = self.tvar_scope
-        self.classdef_tvar_scopes = []
         self.function_stack = []
         self.block_depth = [0]
         self.loop_depth = 0
@@ -429,7 +423,7 @@ def update_function_type_variables(self, fun_type: CallableType, defn: FuncItem)
         Update the signature of defn to contain type variable definitions
         if defn is generic.
         """
-        with self.tvar_scope_frame():
+        with self.tvar_scope_frame(self.tvar_scope.method_frame()):
             a = self.type_analyzer()
             fun_type.variables = a.bind_function_type_variables(fun_type, defn)
 
@@ -547,7 +541,7 @@ def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -
 
     def analyze_function(self, defn: FuncItem) -> None:
         is_method = self.is_class_scope()
-        with self.tvar_scope_frame():
+        with self.tvar_scope_frame(self.tvar_scope.method_frame()):
             if defn.type:
                 self.check_classvar_in_signature(defn.type)
                 assert isinstance(defn.type, CallableType)
@@ -627,7 +621,7 @@ def visit_class_def(self, defn: ClassDef) -> None:
 
     @contextmanager
     def analyze_class_body(self, defn: ClassDef) -> Iterator[bool]:
-        with self.classdef_tvar_scope_frame():
+        with self.tvar_scope_frame(self.tvar_scope.class_frame()):
             self.clean_up_bases_and_infer_type_variables(defn)
             if self.analyze_typeddict_classdef(defn
8000
):
                 yield False
@@ -762,7 +756,7 @@ def clean_up_bases_and_infer_type_variables(self, defn: ClassDef) -> None:
             del defn.base_type_exprs[i]
         tvar_defs = []  # type: List[TypeVarDef]
         for name, tvar_expr in declared_tvars:
-            tvar_defs.append(self.tvar_scope.bind_class_tvar(name, tvar_expr))
+            tvar_defs.append(self.tvar_scope.bind(name, tvar_expr))
         defn.type_vars = tvar_defs
 
     def analyze_typevar_declaration(self, t: Type) -> Optional[TypeVarList]:
@@ -791,12 +785,9 @@ def analyze_unbound_tvar(self, t: Type) -> Tuple[str, TypeVarExpr]:
         sym = self.lookup_qualified(unbound.name, unbound)
         if sym is None or sym.kind != TVAR:
             return None
-        elif self.tvar_scope.get_binding(sym):
+        elif not self.tvar_scope.allow_binding(sym.fullname):
             # It's bound by our type variable scope
             return None
-        elif any(s.get_binding(sym) for s in self.classdef_tvar_scopes):
-            # It's bound by some outer class's type variable scope
-            return None
         else:
             assert isinstance(sym.node, TypeVarExpr)
             return unbound.name, sym.node
@@ -3032,33 +3023,11 @@ def visit_await_expr(self, expr: AwaitExpr) -> None:
     #
 
     @contextmanager
-    def tvar_scope_frame(self) -> Generator:
-        """Prepare our TypeVarScope for a function or method"""
-        old_scope = self.tvar_scope
-        old_function_scope = self.function_tvar_scope
-        self.tvar_scope = TypeVarScope(self.tvar_scope)
-        self.function_tvar_scope = self.tvar_scope
-        yield
-        self.function_tvar_scope = old_function_scope
-        self.tvar_scope = old_scope
-
-    @contextmanager
-    def classdef_tvar_scope_frame(self) -> Generator:
-        """Prepare our TypeVarScope stack for a newly-declared class.
-
-        The scope for an inner class is based on the surrounding function
-        TypeVarScope, not the surrounding class's -- but it's still an error to
-        try and bind the same variable as the surrounding class, so we keep a
-        stack of those around.
-        """
-        old_class_scope = self.classdef_tvar_scopes
+    def tvar_scope_frame(self, frame: TypeVarScope) -> Generator:
         old_scope = self.tvar_scope
-        new_scope = TypeVarScope(self.function_tvar_scope)
-        self.classdef_tvar_scopes = old_class_scope + [new_scope]
-        self.tvar_scope = new_scope
+        self.tvar_scope = frame
         yield
         self.tvar_scope = old_scope
-        self.classdef_tvar_scopes = old_class_scope
 
     def lookup(self, name: str, ctx: Context) -> SymbolTableNode:
         """Look up an unqualified name in all active namespaces."""

diff --git a/mypy/tvar_scope.py b/mypy/tvar_scope.py
@@ -4,28 +4,58 @@
 
 
 class TypeVarScope:
-    """Scope that holds bindings for type variables. Node fullname -> TypeVarDef.
+    """Scope that holds bindings for type variables. Node fullname -> TypeVarDef."""
 
-    Provide a parent on intitalization when you want to make a child scope."""
+    def __init__(self,
+                 parent: Optional['TypeVarScope'] = None,
+                 is_class_scope: bool = False,
+                 prohibited: Optional['TypeVarScope'] = None) -> None:
+        """Initializer for TypeVarScope
 
-    def __init__(self, parent: Optional['TypeVarScope'] = None) -> None:
+        Parameters:
+        parent: the outer scope for this scope
+        is_class_scope: True if this represents a generic class
+        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, TypeVarDef]
         self.parent = parent
         self.func_id = 0
         self.class_id = 0
+        self.is_class_scope = is_class_scope
+        self.prohibited = prohibited
         if parent is not None:
             self.func_id = parent.func_id
             self.class_id = parent.class_id
 
-    def bind_fun_tvar(self, name: str, tvar_expr: TypeVarExpr) -> TypeVarDef:
-        self.func_id -= 1
-        return self._bind(name, tvar_expr, self.func_id)
+    def get_function_scope(self) -> Optional['TypeVarScope']:
+        it = self
+        while it.is_class_scope:
+            it = it.parent
+        return it
 
-    def bind_class_tvar(self, name: str, tvar_expr: TypeVarExpr) -> TypeVarDef:
-        self.class_id += 1
-        return self._bind(name, tvar_expr, self.class_id)
+    def allow_binding(self, fullname: str) -> bool:
+        if fullname in self.scope:
+            return False
+        elif self.parent and not self.parent.allow_binding(fullname):
+            return False
+        elif self.prohibited and not self.prohibited.allow_binding(fullname):
+            return False
+        return True
+
+    def method_frame(self) -> 'TypeVarScope':
+        return TypeVarScope(self, False, None)
 
-    def _bind(self, name: str, tvar_expr: TypeVarExpr, i: int) -> TypeVarDef:
+    def class_frame(self) -> 'TypeVarScope':
+        return TypeVarScope(self.get_function_scope(), True, self)
+
+    def bind(self, name: str, tvar_expr: TypeVarExpr) -> TypeVarDef:
+        if self.is_class_scope:
+            self.class_id += 1
+            i = self.class_id
+        else:
+            self.func_id -= 1
+            i = self.func_id
         tvar_def = TypeVarDef(
             name, i, values=tvar_expr.values,
             upper_bound=tvar_expr.upper_bound, variance=tvar_expr.variance,

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -408,7 +408,7 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
     @contextmanager
     def tvar_scope_frame(self) -> Generator:
         old_scope = self.tvar_scope
-        self.tvar_scope = TypeVarScope(self.tvar_scope)
+        self.tvar_scope = self.tvar_scope.method_frame()
         yield
         self.tvar_scope = old_scope
 
@@ -437,16 +437,19 @@ def bind_function_type_variables(self,
             for var in fun_type.variables:
                 var_expr = self.lookup(var.name, var).node
                 assert isinstance(var_expr, TypeVarExpr)
-                self.tvar_scope.bind_fun_tvar(var.name, var_expr)
+                self.tvar_scope.bind(var.name, var_expr)
             return fun_type.variables
         typevars = self.infer_type_variables(fun_type)
         # 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[TypeVarDef]
         for name, tvar in typevars:
-            self.tvar_scope.bind_fun_tvar(name, tvar)
+            if not self.tvar_scope.allow_binding(tvar.fullname()):
+                self.fail("Type variable '{}' is bound by an outer class".format(name), defn)
+            self.tvar_scope.bind(name, tvar)
             defs.append(self.tvar_scope.get_binding(tvar.fullname()))
+
         return defs
 
     def is_defined_type_var(self, tvar: str, context: Context) -> bool:

diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
@@ -1347,7 +1347,17 @@ class A(Generic[T]):
             self.a = a
         g(self.a)
         g(n) # E: Argument 1 to "g" has incompatible type "int"; expected "T"
-[out]
+
+[case testFunctionInGenericInnerClassTypeVariable]
+from typing import TypeVar, Generic
+
+T = TypeVar('T')
+class Outer(Generic[T]):
+    class Inner:
+        x: T  # E: Invalid type "__main__.T"
+        def f(self, x: T) -> T: ...  # E: Type variable 'T' is bound by an outer class
+        def g(self) -> None:
+            y: T  # E: Invalid type "__main__.T"
 
 
 -- Callable subtyping with generic functions