Try alternative implementation of exceptions

Author: ilevkivskyi

mypy/typeops.py

@@ -329,11 +329,13 @@ def class_callable(
     variables.extend(info.defn.type_vars)
     variables.extend(init_type.variables)
 
-    from mypy.subtypes import is_subtype
+    from mypy.subtypes import is_equivalent, is_subtype
 
     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)
+    # Default return type in the class where constructor method was defined.
+    default_def_ret_type = fill_typevars(def_info) if def_info is not None else default_ret_type
     explicit_type = init_ret_type if is_new else orig_self_type
     if (
         is_new
@@ -345,9 +347,9 @@ def class_callable(
         #     class D(C): ...
         # So we need to ignore the explicit annotation when creating constructor type for D.
         and (
-            def_info is info
-            and not isinstance(explicit_type, AnyType)
-            or not is_subtype(default_ret_type, explicit_type, ignore_type_params=True)
+            isinstance(explicit_type, AnyType)
+            and explicit_type.type_of_any != TypeOfAny.unannotated
+            or not is_equivalent(default_def_ret_type, explicit_type, ignore_type_params=True)
         )
     ):
         ret_type = explicit_type

test-data/unit/check-classes.test

@@ -7317,7 +7317,7 @@ reveal_type(B())  # N: Revealed type is "__main__.B"
 [case testNewReturnType2]
 from typing import Any
 
-# make sure that __new__ method that return Any are ignored when
+# make sure that __new__ method that return implicit Any are ignored when
 # determining the return type
 class A:
     def __new__(cls):
@@ -7328,7 +7328,7 @@ class B:
         pass
 
 reveal_type(A())  # N: Revealed type is "__main__.A"
-reveal_type(B())  # N: Revealed type is "__main__.B"
+reveal_type(B())  # N: Revealed type is "Any"
 
 [case testNewReturnType3]
 
@@ -7536,9 +7536,11 @@ class C(B): ...
 
 # Always respect explicit return type after giving an error.
 reveal_type(B())  # N: Revealed type is "__main__.A"
+reveal_type(C())  # N: Revealed type is "__main__.A"
 
 # Ignore "implicit" return type to preserve backwards compatibility.
-reveal_type(C())  # N: Revealed type is "__main__.C"
+class D(A): ...
+reveal_type(D())  # N: Revealed type is "__main__.D"
 
 [case testNewReturnType19]
 from typing import TypeVar