`overload`s not recognised when `self` is typed as a `Protocol`

[cmp0xff]

Bug Report

When subclassing a base class with overloads, and self is typed as a Protocol, only the first overload is recognised.

To Reproduce

from datetime import timedelta
from typing import Generic, Protocol, TypeVar, overload, reveal_type


T = TypeVar("T")
T_CT = TypeVar("T_CT", contravariant=True)

class Mixin(Generic[T]):
    @overload
    def d(self: Mixin[timedelta], other: float) -> Mixin[timedelta]: ...
    @overload
    def d(self: Mixin[timedelta], other: timedelta) -> Mixin[float]: ...

reveal_type(Mixin[timedelta]().d(5.0))  # Mixin[timedelta], fine
reveal_type(Mixin[timedelta]().d(timedelta(days=1)))  # Mixin[float], fine

class SupportsD(Protocol[T_CT, T]):
    def d(self, other: T_CT, /) -> Mixin[T]: ...

class S(Mixin[T]):
    def div(self: SupportsD[T_CT, T], other: T_CT) -> S[T]: ...

reveal_type(S[timedelta]().div(5.0))  # S[timedelta], fine
reveal_type(S[timedelta]().div(timedelta(days=1)))  # mypy arg-type

Expected Behavior

S[timedelta]().div(timedelta(days=1)) is revealed as S[float]

Actual Behavior

ttest.pyi:24: error: Argument 1 to "div" of "S" has incompatible type "timedelta"; expected "float"  [arg-type]

Your Environment

Mypy version used

1.18.2

Mypy command-line flags

none

Mypy configuration options from mypy.ini (and other config files):

[tool.mypy]
# Import discovery
namespace_packages = false
explicit_package_bases = false
ignore_missing_imports = true
follow_imports = "normal"
follow_imports_for_stubs = false
no_site_packages = false
no_silence_site_packages = false
# Disallow dynamic typing
disallow_any_unimported = false  # TODO
disallow_any_expr = false        # TODO
disallow_any_decorated = false   # TODO
disallow_any_explicit = false    # TODO
disallow_any_generics = false    # TODO
disallow_subclassing_any = false # TODO
# Untyped definitions and calls
disallow_untyped_calls = false     # TODO
disallow_untyped_defs = false      # TODO
disallow_incomplete_defs = false   # TODO
check_untyped_defs = true
disallow_untyped_decorators = true
# None and Optional handling
no_implicit_optional = true
strict_optional = true
# Configuring warnings
warn_redundant_casts = true
warn_unused_ignores = true
warn_no_return = true
warn_return_any = false     # TODO
warn_unreachable = false    # GH#27396
# Suppressing errors
ignore_errors = false
enable_error_code = "ignore-without-code" # same as in pandas
# Miscellaneous strictness flags
allow_untyped_globals = false
allow_redefinition = false
local_partial_types = false
implicit_reexport = false     # pyright behaves the same
strict_equality = true
# Configuring error messages
show_error_context = false
show_column_numbers = false
show_error_codes = true

Python version used:

3.12.10

[sterliakov]

Looks like this TODO from 2012:

mypy/mypy/constraints.py

Lines 1239 to 1248 in f09aa57

	def infer_against_overloaded(
	self, overloaded: Overloaded, template: CallableType
	) -> list[Constraint]:
	# Create constraints by matching an overloaded type against a template.
	# This is tricky to do in general. We cheat by only matching against
	# the first overload item that is callable compatible. This
	# seems to work somewhat well, but we should really use a more
	# reliable technique.
	item = find_matching_overload_item(overloaded, template)
	return infer_constraints(template, item, self.direction)