.

Author: hauntsaninja

mypy/erasetype.py

@@ -102,11 +102,13 @@ def visit_unpack_type(self, t: UnpackType) -> ProperType:
     def visit_callable_type(self, t: CallableType) -> ProperType:
         # We must preserve the fallback type for overload resolution to work.
         any_type = AnyType(TypeOfAny.special_form)
+        # If we're a type object, make sure we continue to be a valid type object
+        ret_type = t.ret_type if t.is_type_obj() else any_type
         return CallableType(
             arg_types=[any_type, any_type],
             arg_kinds=[ARG_STAR, ARG_STAR2],
             arg_names=[None, None],
-            ret_type=any_type,
+            ret_type=ret_type,
             fallback=t.fallback,
             is_ellipsis_args=True,
             implicit=True,

mypy/meet.py

@@ -657,7 +657,7 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
 def is_overlapping_erased_types(
     left: Type, right: Type, *, ignore_promotions: bool = False
 ) -> bool:
-    """The same as 'is_overlapping_erased_types', except the types are erased first."""
+    """The same as 'is_overlapping_types', except the types are erased first."""
     return is_overlapping_types(
         erase_type(left), erase_type(right), ignore_promotions=ignore_promotions
     )

mypy/subtypes.py

@@ -1696,6 +1696,11 @@ def g(x: int) -> int: ...
     if right.is_type_obj() and not left.is_type_obj() and not allow_partial_overlap:
         return False
 
+    if left.is_type_obj():
+        left_type_obj = left.type_object()
+        if (left_type_obj.is_protocol or left_type_obj.is_abstract) and not right.is_type_obj():
+            return False
+
     # A callable L is a subtype of a generic callable R if L is a
     # subtype of every type obtained from R by substituting types for
     # the variables of R. We can check this by simply leaving the

mypy/test/testtypes.py

@@ -318,7 +318,7 @@ def test_erase_with_type_object(self) -> None:
                 arg_types=[self.fx.anyt, self.fx.anyt],
                 arg_kinds=[ARG_STAR, ARG_STAR2],
                 arg_names=[None, None],
-                ret_type=self.fx.anyt,
+                ret_type=self.fx.b,
                 fallback=self.fx.type_type,
             ),
         )

test-data/unit/check-abstract.test

@@ -1688,3 +1688,24 @@ from typing import TYPE_CHECKING
 class C:
     if TYPE_CHECKING:
         def dynamic(self) -> int: ...  # OK
+
+[case testAbstractCallableSubtyping]
+import abc
+from typing import Callable, Protocol
+
+class Proto(Protocol):
+    def meth(self): ...
+
+def foo(t: Callable[..., Proto]):
+    t()
+
+foo(Proto)  # E: Argument 1 to "foo" has incompatible type "Type[Proto]"; expected "Callable[..., Proto]"
+
+class Abstract(abc.ABC):
+    @abc.abstractmethod
+    def meth(self): ...
+
+def bar(t: Callable[..., Abstract]):
+    t()
+
+bar(Abstract)  # E: Argument 1 to "bar" has incompatible type "Type[Abstract]"; expected "Callable[..., Abstract]"

test-data/unit/check-functools.test

@@ -594,7 +594,8 @@ def f1(cls: type[A]) -> None:
 
 def f2() -> None:
     A()  # E: Cannot instantiate abstract class "A" with abstract attribute "method"
-    partial_cls = partial(A)  # E: Cannot instantiate abstract class "A" with abstract attribute "method"
+    partial_cls = partial(A)  # E: Cannot instantiate abstract class "A" with abstract attribute "method" \
+                              # E: Argument 1 to "partial" has incompatible type "Type[A]"; expected "Callable[..., A]"
     partial_cls()  # E: Cannot instantiate abstract class "A" with abstract attribute "method"
 [builtins fixtures/tuple.pyi]
 

test-data/unit/check-optional.test

@@ -1355,3 +1355,19 @@ def f(x: object) -> None:
         with C():
             pass
 [builtins fixtures/tuple.pyi]
+
+[case testRefineAwayNoneCallbackProtocol]
+# Regression test for issue encountered in https://github.com/python/mypy/pull/18347#issuecomment-2564062070
+from __future__ import annotations
+from typing import Protocol
+
+class CP(Protocol):
+    def __call__(self, parameters: str) -> str: ...
+
+class NotSet: ...
+
+class Task:
+    def with_opt(self, trn: CP | type[NotSet] | None):
+        if trn is not NotSet:
+            reveal_type(trn)  # N: Revealed type is "Union[__main__.CP, Type[__main__.NotSet], None]"
+[builtins fixtures/tuple.pyi]