Do not handle NotImplementedType as Any anymore.

Author: tyralla

mypy/checker.py

@@ -4942,13 +4942,6 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                             s.expr, return_type, allow_none_return=allow_none_func_call
                         )
                     )
-                # Treat NotImplemented as having type Any, consistent with its
-                # definition in typeshed prior to python/typeshed#4222.
-                if (
-                    isinstance(typ, Instance)
-                    and typ.type.fullname == "builtins._NotImplementedType"
-                ):
-                    typ = AnyType(TypeOfAny.special_form)
 
                 if defn.is_async_generator:
                     self.fail(message_registry.RETURN_IN_ASYNC_GENERATOR, s)
@@ -4961,10 +4954,6 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                         self.options.warn_return_any
                         and not self.current_node_deferred
                         and not is_proper_subtype(AnyType(TypeOfAny.special_form), return_type)
-                        and not (
-                            defn.name in BINARY_MAGIC_METHODS
-                            and is_literal_not_implemented(s.expr)
-                        )
                         and not (
                             isinstance(return_type, Instance)
                             and return_type.type.fullname == "builtins.object"
@@ -4982,6 +4971,14 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                     if is_lambda or isinstance(typ, NoneType):
                         return
                     self.fail(message_registry.NO_RETURN_VALUE_EXPECTED, s)
+                elif (
+                    isinstance(typ, Instance)
+                    and typ.type.fullname == "builtins._NotImplementedType"
+                    and (
+                        (defn.name in BINARY_MAGIC_METHODS or defn.name == "__subclasshook__")
+                    )
+                ):
+                    return
                 else:
                     self.check_subtype(
                         subtype_label="got",

mypy/mro.py

@@ -15,8 +15,12 @@ def calculate_mro(info: TypeInfo, obj_type: Callable[[], Instance] | None = None
     mro = linearize_hierarchy(info, obj_type)
     assert mro, f"Could not produce a MRO at all for {info}"
     info.mro = mro
-    # The property of falling back to Any is inherited.
-    info.fallback_to_any = any(baseinfo.fallback_to_any for baseinfo in info.mro)
+    # The property of falling back to Any is (usually) inherited.
+    if info.fullname == "builtins._NotImplementedType":
+        info.fallback_to_any = False
+    else:
+        info.fallback_to_any = any(baseinfo.fallback_to_any for baseinfo in info.mro)
+
     type_state.reset_all_subtype_caches_for(info)
 
 

test-data/unit/check-overloading.test

@@ -6852,3 +6852,25 @@ if isinstance(headers, dict):
 
 reveal_type(headers)  # N: Revealed type is "Union[__main__.Headers, typing.Iterable[tuple[builtins.bytes, builtins.bytes]]]"
 [builtins fixtures/isinstancelist.pyi]
+
+[case testReturnNotImplementedInBinaryMagicMethods]
+class A:
+    def __eq__(self, other: object) -> bool: return NotImplemented
+[builtins fixtures/notimplemented.pyi]
+
+[case testReturnNotImplementedABCSubclassHookMethod]
+class A:
+    @classmethod
+    def __subclasshook__(cls, t: type[object], /) -> bool:
+        return NotImplemented
+[builtins fixtures/notimplemented.pyi]
+
+[case testReturnNotImplementedInNormalMethods]
+from typing import Union
+class A:
+    def f(self) -> bool: return NotImplemented  # E: Incompatible return value type (got "_NotImplementedType", expected "bool")
+    def g(self) -> NotImplementedType: return True # E: Incompatible return value type (got "bool", expected "_NotImplementedType")
+    def h(self) -> NotImplementedType: return NotImplemented
+    def i(self) -> Union[bool, NotImplementedType]: return NotImplemented
+    def j(self) -> Union[bool, NotImplementedType]: return True
+[builtins fixtures/notimplemented.pyi]

test-data/unit/check-warnings.test

@@ -178,21 +178,6 @@ def f() -> int: return g()
 [out]
 main:4: error: Returning Any from function declared to return "int"
 
-[case testReturnAnyForNotImplementedInBinaryMagicMethods]
-# flags: --warn-return-any
-class A:
-    def __eq__(self, other: object) -> bool: return NotImplemented
-[builtins fixtures/notimplemented.pyi]
-[out]
-
-[case testReturnAnyForNotImplementedInNormalMethods]
-# flags: --warn-return-any
-class A:
-    def some(self) -> bool: return NotImplemented
-[builtins fixtures/notimplemented.pyi]
-[out]
-main:3: error: Returning Any from function declared to return "bool"
-
 [case testReturnAnyFromTypedFunctionWithSpecificFormatting]
 # flags: --warn-return-any
 from typing import Any, Tuple

test-data/unit/fixtures/notimplemented.pyi

@@ -9,10 +9,14 @@ class function: pass
 class bool: pass
 class int: pass
 class str: pass
+class tuple: pass
 class dict: pass
+class classmethod: pass
 
 class _NotImplementedType(Any):
     __call__: NotImplemented  # type: ignore
 NotImplemented: _NotImplementedType
 
+NotImplementedType = _NotImplementedType
+
 class BaseException: pass