Ignore invalid self types in constructor (python#7946)

ilevkivskyi · web-flow · commit f136e29084e4 · 2019-11-13T15:50:24.000Z
This previously caused small troubles in Dropbox internal codebase C (because of weird annotations).

For example if an `__init__()` of class `C` had its `self` argument annotated with one of its superclasses `B`, this made all calls to `C()` inferred as `B`, causing spurious errors.

This PR also makes explicit types in `__new__()` and `__init__()` treated in a more similar way.
diff --git a/mypy/typeops.py b/mypy/typeops.py
@@ -74,7 +74,7 @@ def type_object_type_from_function(signature: FunctionLike,
     # see comment in class_callable below). This is mostly useful for annotating library
     # classes such as subprocess.Popen.
     default_self = fill_typevars(info)
-    if not is_new and def_info == info and not info.is_newtype:
+    if not is_new and not info.is_newtype:
         orig_self_types = [(it.arg_types[0] if it.arg_types and it.arg_types[0] != default_self
                             and it.arg_kinds[0] == ARG_POS else None) for it in signature.items()]
     else:
@@ -122,16 +122,14 @@ def class_callable(init_type: CallableType, info: TypeInfo, type_type: Instance,
     init_ret_type = get_proper_type(init_type.ret_type)
     orig_self_type = get_proper_type(orig_self_type)
     default_ret_type = fill_typevars(info)
+    explicit_type = init_ret_type if is_new else orig_self_type
     if (
-        is_new
-        and isinstance(init_ret_type, (Instance, TupleType))
-        # Only use the return type from __new__ if it is actually returning
-        # a subtype of what we would return otherwise.
-        and is_subtype(init_ret_type, default_ret_type, ignore_type_params=True)
+        isinstance(explicit_type, (Instance, TupleType))
+        # Only use the declared return type from __new__ or declared self in __init__
+        # if it is actually returning a subtype of what we would return otherwise.
+        and is_subtype(explicit_type, default_ret_type, ignore_type_params=True)
     ):
-        ret_type = init_ret_type  # type: Type
-    elif isinstance(orig_self_type, (Instance, TupleType)):
-        ret_type = orig_self_type
+        ret_type = explicit_type  # type: Type
     else:
         ret_type = default_ret_type
 
diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
@@ -1009,3 +1009,49 @@ def bar(x: AClass) -> None:
     reveal_type(x.delete)  # N: Revealed type is 'Overload(def (id: builtins.int, id2: builtins.int) -> builtins.int, def (id: __main__.AClass*, id2: None =) -> builtins.int)'
     x.delete(10, 20)
 [builtins fixtures/classmethod.pyi]
+
+[case testSelfTypeBadTypeIgnoredInConstructor]
+class Base: ...
+class Sub(Base):
+    def __init__(self: Base) -> None: ...
+
+reveal_type(Sub())  # N: Revealed type is '__main__.Sub'
+
+[case testSelfTypeBadTypeIgnoredInConstructorGeneric]
+from typing import Generic, TypeVar
+
+T = TypeVar('T')
+
+class Base(Generic[T]): ...
+class Sub(Base[T]):
+    def __init__(self: Base[T], item: T) -> None: ...
+
+reveal_type(Sub(42))  # N: Revealed type is '__main__.Sub[builtins.int*]'
+
+[case testSelfTypeBadTypeIgnoredInConstructorOverload]
+from typing import overload
+
+class Base: ...
+class Sub(Base):
+    @overload
+    def __init__(self: Sub, item: int) -> None: ...
+    @overload
+    def __init__(self: Base) -> None: ...
+    def __init__(self, item=None):
+        ...
+
+reveal_type(Sub)  # N: Revealed type is 'Overload(def (item: builtins.int) -> __main__.Sub, def () -> __main__.Sub)'
+
+[case testSelfTypeBadTypeIgnoredInConstructorAbstract]
+from abc import abstractmethod
+from typing import Protocol
+
+class Blah(Protocol):
+    @abstractmethod
+    def something(self) -> None: ...
+
+class Concrete(Blah):
+    def __init__(self: Blah) -> None: ...
+    def something(self) -> None: ...
+
+Concrete()  # OK
