explode operator shouldn't be allowed for calls to arrity overloaded functions

In the test below the intention is that if test is called with one argument that it returns str, and if it is called with multiple that it returns list[str]. The assert will trip at runtime even though the example type checks. The documentation already warns that mypy can't do a perfect job of making sure that your actual implementation function respects the declarations, however, AFAICT there is no correct way to implement test, which makes me think that either this type of overloading should be forbidden or you should be forbidden from using the explode operator when calling such a function (foo, bar, *buzz would be fine but not just *buzz). mypy seems to assume that if you use the explode operator you must mean the overload that takes more than one argument, but in practice because the test implementation can't actually distinguish an explode operator using call from a regular call, the best that it can do is check how many arguments it actually received and assume that you mean the first overload if there is only 1.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from typing import overload

@overload
def test(x: str) -> str:
    assert False

@overload
def test(x: str, x2: str, *xn: str) -> list[str]:
    assert False

def test(x: str, x2: str | None = None, *xn: str) -> str | list[str]:
    allx = [x]
    if x2 is not None:
        allx.append(x2)
    allx.extend(xn)

    if len(allx) == 1:
        return allx[0]
    return allx

y = ["hi"]
z: list[str] = test(*y)
assert isinstance(z, list)

Inizia con il riproduttore nell’issue e segui il modo in cui mypy risolve le chiamate sovraccariche usando l’explode operator. Determina se la chiamata debba essere rifiutata o risolta diversamente, quindi aggiungi una copertura di regressione che dimostri che l’esempio segnalato non supera più erroneamente il controllo dei tipi.