False positive for overload parameters overlapping with specific recursive types

[Kajiih]

Describe the bug
There seems to be a false positive for overload parameters overlapping, happening specifically with some recursive types.

I couldn't point out the exact issue, so here's an example:
Code or Screenshots
It is not really a minimal example, but I tried to keep some context. In particular, the protocol CallableArbitraryNbArgs was originally generic, but the false positive happens in both generic and non-generic cases.

The false positive happens when using NestedMapping which is a recursive type that involves NestedMappingNode, but not when using NestedMapping2, that doesn't.

from collections.abc import Callable, Mapping
from typing import Any, Protocol, overload

type NestedMapping[K, V] = Mapping[K, NestedMappingNode[K, V]]
type NestedMappingNode[K, V] = V | NestedMapping[K, V]


type NestedMapping2[K, V] = Mapping[K, NestedMapping2[K, V]]


class CallableArbitraryNbArgs(Protocol):
    """Protocol for a callable that accepts an arbitrary number of arguments."""

    def __call__(self, *args: Any) -> Any: ...  # noqa: D102


# === With NestedMapping: false positive ===
@overload
def map_leaves_1[K, V, W](
    func: CallableArbitraryNbArgs,
    *nested_dicts: NestedMapping[K, V],
) -> NestedMapping[K, W]: ...


# Overload 2 for "map_leaves_no_generic_protocol" will never be used because its parameters overlap overload 1
@overload
def map_leaves_1[K, W](
    func: Callable[..., W],
    *nested_dicts: NestedMapping[K, Any],
) -> NestedMapping[K, W]: ...


def map_leaves_1[K, W](
    func: Callable[..., W] | CallableArbitraryNbArgs, *nested_dicts: NestedMapping[K, Any]
) -> NestedMapping[K, W]:
    del nested_dicts
    del func
    raise NotImplementedError


# === With NestedMapping2: no error ===
@overload
def map_leaves_2[K, V, W](
    func: CallableArbitraryNbArgs,
    *nested_dicts: NestedMapping2[K, V],
) -> NestedMapping[K, W]: ...


@overload
def map_leaves_2[K, W](
    func: Callable[..., W],
    *nested_dicts: NestedMapping2[K, Any],
) -> NestedMapping[K, W]: ...


def map_leaves_2[K, W](
    func: Callable[..., W] | CallableArbitraryNbArgs, *nested_dicts: NestedMapping2[K, Any]
) -> NestedMapping[K, W]:
    del nested_dicts
    del func
    raise NotImplementedError

If I'm not mistaking, the overload parameters don't overlap in either case.

VS Code extension or command-line
Both extension and command line, Pylance and Pyright version 1.1.389

[erictraut]

Thanks for the bug report. I agree that this should not be considered a fully-overlapping override, but perhaps not for the reason you think. It has nothing to do with recursive types. It's because CallableArbitraryNbArgs does not accept keyword arguments.

Here's a code sample that demonstrates how a callback function with keyword parameters would not be accepted by the first overload but would be accepted by the second.

from typing import Any, Callable, Protocol

class CB(Protocol):
    def __call__(self, *args: Any) -> Any: ...

def overload1(func: CB) -> None: ...
def overload2(func: Callable[..., Any]) -> None: ...

def cb(*, x: int) -> None: ...

overload1(cb)  # Error
overload2(cb)

[Kajiih]

Thank you.
Indeed, there is the same error when we remove the *nested_dicts parameters altogether. But another thing that's confusing here is that the behavior changes when the type of *nested_dicts changes in the example. Specifically, it is not considered fully overlapping in the second case.

[erictraut]

This is addressed in pyright 1.1.390.