Support classes with @overload-ed __init__.

Guido van Rossum · Guido van Rossum · commit b9dcb7cd67be · 2016-05-25T19:04:40.000-07:00
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -304,12 +304,19 @@ def analyze_type_type_callee(self, item: Type, context: Context) -> Type:
             # but better than AnyType...), but replace the return type
             # with typevar.
             callee = self.analyze_type_type_callee(item.upper_bound, context)
-            if not isinstance(callee, CallableType):
-                # Might be a union.
-                # XXX What to do for Overloaded?
+            if isinstance(callee, CallableType):
+                if callee.is_generic():
+                    callee = None
+                else:
+                    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()])
+            if callee:
                 return callee
-            if not callee.is_generic():
-                return callee.copy_modified(ret_type=item)
 
         self.msg.unsupported_type_type(item, context)
         return AnyType()
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -357,6 +357,9 @@ def visit_overloaded(self, template: Overloaded) -> List[Constraint]:
     def visit_type_type(self, template: TypeType) -> List[Constraint]:
         if isinstance(self.actual, CallableType) and self.actual.is_type_obj():
             return infer_constraints(template.item, self.actual.ret_type, self.direction)
+        elif isinstance(self.actual, Overloaded) and self.actual.is_type_obj():
+            return infer_constraints(template.item, self.actual.items()[0].ret_type,
+                                     self.direction)
         elif isinstance(self.actual, TypeType):
             return infer_constraints(template.item, self.actual.item, self.direction)
         else:
diff --git a/mypy/test/data/check-classes.test b/mypy/test/data/check-classes.test
@@ -1607,3 +1607,20 @@ def foo(arg: Type[Tuple[int]]):  # E: Unsupported type Type["Tuple[int]"]
 [builtins fixtures/tuple.py]
 [out]
 main: note: In function "foo":
+
+[case testTypeUsingTypeCOverloadedClass]
+from typing import Type, TypeVar, overload
+class User:
+    @overload
+    def __init__(self) -> None: pass
+    @overload
+    def __init__(self, arg: int) -> None: pass
+    @classmethod
+    def foo(cls) -> None: pass
+U = TypeVar('U', bound=User)
+def new(uc: Type[U]) -> U:
+    uc.foo()
+    return uc()
+u = new(User)
+[builtins fixtures/classmethod.py]
+[out]
