Allow calling Type[T] where T has generic bound (#5309)

Fix #3631 : looks like it was an explicit decision, made before we had self types.

The code modified in this PR was introduced at #1569. There are no tests for the current behavior, and it seems like we actually want to allow it.

Author: elazarg

mypy/checkexpr.py

@@ -716,16 +716,10 @@ def analyze_type_type_callee(self, item: Type, context: Context) -> Type:
             callee = self.analyze_type_type_callee(item.upper_bound,
                                                    context)  # type: Optional[Type]
             if isinstance(callee, CallableType):
-                if callee.is_generic():
-                    callee = None
-                else:
-                    callee = callee.copy_modified(ret_type=item)
+                callee = callee.copy_modified(ret_type=item)
             elif isinstance(callee, Overloaded):
-                if callee.items()[0].is_generic():
-                    callee = None
-                else:
-                    callee = Overloaded([c.copy_modified(ret_type=item)
-                                         for c in callee.items()])
+                callee = Overloaded([c.copy_modified(ret_type=item)
+                                     for c in callee.items()])
             if callee:
                 return callee
 

test-data/unit/check-generics.test

@@ -1778,6 +1778,16 @@ def f(c: Type[T]) -> T: ...
 x: Any
 reveal_type(f(x))  # E: Revealed type is 'Any'
 
+[case testCallTypeTWithGenericBound]
+from typing import Generic, TypeVar, Type
+T = TypeVar('T')
+S = TypeVar('S', bound='A')
+
+class A(Generic[T]): pass
+
+def f(cls: Type[S]) -> None:
+    cls()
+
 [case testQualifiedTypeVariableName]
 import b
 def f(x: b.T) -> b.T: return x