Looks related to #14978 (Numpy uses generic self parameters for its operator overloads)

It looks like there is some exponential behavior. If I reduce the number of type variables by two, type checking completes in about 6 seconds (using interpreted mypy). Would anybody interested in investigating this? The next step would be to collect a CPU profile and debug the hottest functions to understand what is going on. Once we understand the exponential behavior, a fix would hopefully be relatively easy.

Here is an example that completes type checking in a reasonable time but is still unexpectedly slow:

from typing import TypeVar, Generic, TypeAlias, overload, Any


T1 = TypeVar('T1', int, str, bool)
T2 = TypeVar('T2', int, str, bool)
T3 = TypeVar('T3', int, str, bool)
T4 = TypeVar('T4', int, str, bool)
T5 = TypeVar('T5', int, str, bool)


class A(Generic[T1, T2, T3, T4, T5]):
    @overload
    def foo(self: A[int, T2, T3, T4, T5]) -> int:
        ...

    @overload
    def foo(self: A[str, T2, T3, T4, T5]) -> str:
        ...

    def foo(self) -> int | str:
        raise NotImplementedError

py-spy profiling results with 6 type arguments looks like this:

Thanks! Clearly check_overlapping_overloads is a bottleneck. Maybe it has some exponential behavior that we can fix.

Based on the profile, my guess is that #14978 is a different issue. This seems related to processing the overload definition, whereas #14978 is related to type checking calls to an overloaded function.