`@overload` incorrectly reports error if overload param would go to different params of implementation depending on positional vs keyword calling style

Bug Report

Type-checking on the @overload decorator incorrectly reports an error in the implementation function's signature when an argument would go to different parameters of an implementation function depending on whether that argument is passed as a positional or keyword argument, even if both outcomes are still valid.

To Reproduce

Here's a minimal possible example:

from typing import overload

@overload
def func(value: int):
    ...

def func(positional_only: int | None = None, /, value: int | None = None):
    pass

func can be correctly called with either of these signatures:

func(1)  # results in call with parameters(1, None)
func(value=1)  # results in call with parameters (None, 1)

Either of these calls is valid.

Expected Behavior

The type-checker considers the code valid. (Excluding the error that there's only one overload, which is expected in this minimal example).

Actual Behavior

type_test.py:8: error: Overloaded function implementation does not accept all possible arguments of signature 1  [misc]

Your Environment

• Mypy version used: mypy 1.7.1 (compiled: yes)
• Mypy command-line flags: python3 -m mypy ./type_test_2.py
• Mypy configuration options from mypy.ini (and other config files): Not changed from the default
• Python version used: Python 3.11.6

A motivating example

I wanted to define a lookup function that can lookup an object by id (an int) or name (a str), something like this:

from typing import overload

@overload
def lookup(id: int):
    ...

@overload
def lookup(name: str):
    ...

def lookup(id_or_name: int | str | None = None, /, id: int | None = None, name: str | None = None):
    if id is None and name is None:
        if isinstance(id_or_name, int): id = id_or_name
        else: name = id_or_name  # name is str

    if id is not None:
        return _lookup_by_id(id)
    else:
        return _lookup_by_name(name)


## Possible calls:

lookup(1)  # integer positional
lookup(id=1)  # integer keyword

lookup("foo")  # string positional
lookup(name="foo")  # string keyword

Inizia eseguendo il comando indicato python3 -m mypy ./type_test_2.py con l’esempio minimo di overload e conferma l’errore della firma dell’implementazione. Traccia il controllo di compatibilità dell’implementazione dell’overload e aggiungi una copertura per le chiamate posizionali e con argomenti keyword che raggiungono parametri di implementazione diversi. Il lavoro è completato quando le chiamate valide non producono più l’errore indicato, mentre le implementazioni di overload non valide continuano a essere rifiutate.