changes

Author: hauntsaninja

mypy/typeops.py

@@ -191,19 +191,27 @@ def class_callable(
     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 (
-        isinstance(explicit_type, (Instance, TupleType, UninhabitedType))
-        # We have to skip protocols, because it can be a subtype of a return type
-        # by accident. Like `Hashable` is a subtype of `object`. See #11799
-        and isinstance(default_ret_type, Instance)
-        and not default_ret_type.type.is_protocol
-        # Only use the declared return type from declared self in __init__
-        # if it is actually returning a subtype of what we would return otherwise.
-        and (is_new or is_subtype(explicit_type, default_ret_type, ignore_type_params=True))
-    ):
-        ret_type: Type = explicit_type
-    else:
-        ret_type = default_ret_type
+
+    ret_type: Type = default_ret_type
+    if isinstance(explicit_type, (Instance, TupleType, UninhabitedType)):
+        if is_new:
+            # For a long time, mypy didn't truly believe annotations on __new__
+            # This has led to some proliferation of code that depends on this, namely
+            # annotations on __new__ that hardcode the class in the return type.
+            # This can then cause problems for subclasses. Preserve the old behaviour in
+            # this case (although we should probably change it at some point)
+            if not is_subtype(default_ret_type, explicit_type, ignore_type_params=True):
+                ret_type = explicit_type
+        elif (
+            # We have to skip protocols, because it can be a subtype of a return type
+            # by accident. Like `Hashable` is a subtype of `object`. See #11799
+            isinstance(default_ret_type, Instance)
+            and not default_ret_type.type.is_protocol
+            # Only use the declared return type from 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 = explicit_type
 
     callable_type = init_type.copy_modified(
         ret_type=ret_type,

test-data/unit/check-classes.test

@@ -6913,8 +6913,8 @@ class O(Generic[T]):
     def __new__(cls, x: int = 0) -> O[Any]:
         pass
 
-reveal_type(O())  # N: Revealed type is "__main__.O[builtins.int]"
-reveal_type(O(10))  # N: Revealed type is "__main__.O[builtins.str]"
+reveal_type(O())  # N: Revealed type is "__main__.O[Never]"
+reveal_type(O(10))  # N: Revealed type is "__main__.O[Never]"
 
 [case testNewReturnType6]
 from typing import Tuple, Optional
@@ -6960,7 +6960,7 @@ class A:
 class B(A):
     pass
 
-reveal_type(B())  # N: Revealed type is "__main__.A"
+reveal_type(B())  # N: Revealed type is "__main__.B"
 
 [case testNewReturnType10]
 # https://github.com/python/mypy/issues/11398
@@ -6993,6 +6993,19 @@ class MyMetaClass(type):
 class MyClass(metaclass=MyMetaClass):
     pass
 
+[case testNewReturnType13]
+from typing import Protocol
+
+class Foo(Protocol):
+    def foo(self) -> str: ...
+
+class A:
+    def __new__(cls) -> Foo: ...  # E: Incompatible return type for "__new__" (returns "Foo", but must return a subtype of "A")
+
+reveal_type(A())  # E: Cannot instantiate protocol class "Foo" \
+                  # N: Revealed type is "__main__.Foo"
+reveal_type(A().foo())  # E: Cannot instantiate protocol class "Foo" \
+                        # N: Revealed type is "builtins.str"
 
 [case testMetaclassPlaceholderNode]
 from sympy.assumptions import ManagedProperties

test-data/unit/check-enum.test

@@ -1360,7 +1360,7 @@ class Bar(Foo):
     A = 1
     B = 2
 
-a = Bar.A  # E: "Type[Foo]" has no attribute "A"
+a = Bar.A
 reveal_type(a.value)    # N: Revealed type is "Any"
 reveal_type(a._value_)  # N: Revealed type is "Any"
 [builtins fixtures/primitives.pyi]