Incomplete assignability implementation between two `Callable` types where one `Callable` type has `*args: Any, **kwargs: Any`

[AlexWaygood]

Summary

The typing spec states:

If the input signature in a function definition includes both a *args and **kwargs parameter and both are typed as Any (explicitly or implicitly because it has no annotation), a type checker should treat this as the equivalent of .... Any other parameters in the signature are unaffected and are retained as part of the signature

And we can see that in the conformance test suite, this test asserts that Proto7 should be understood as being assignable to Proto6: although the signature of Proto7 is less permissive than the signature of Proto6, Proto6 has a gradual signature due to the presence of *args: Any and **kwargs: Any in the signature, so the normal rules do not apply. The definitions of Proto6 and Proto7 in this test are:

from typing import Protocol, Any

class Proto6(Protocol):
    def __call__(self, a: int, /, *args: Any, k: str, **kwargs: Any) -> None: ...

class Proto7(Protocol):
    def __call__(self, a: float, /, b: int, *, k: str, m: str) -> None: ...

Note that both mypy and pyrefly also appear to fail this test currently; only pyright currently passes this test.

A version of this failing test for ty that doesn't involve protocols would be:

from typing import Any
from ty_extensions import CallableTypeOf, is_assignable_to, static_assert

def f(*args: Any, a: int, **kwargs: Any): ...
def g(fwomp: int, /, a: int, *, bar: str, baz: str): ...

static_assert(is_assignable_to(CallableTypeOf[g], CallableTypeOf[f]))

https://play.ty.dev/4f422ed6-1725-4230-b803-a62325e218f6

Version

No response

[carljm]

I think our current implementation only treats a function as having a "gradual signature" if it has *args: Any, **kwargs: Any as its only parameters. I didn't actually realize that functions with *args: Any, **kwargs: Any and other parameters as well were also supposed to be treated specially.

[AlexWaygood]

I didn't actually realize that functions with *args: Any, **kwargs: Any and other parameters as well were also supposed to be treated specially.

No, neither did I. It's quite surprising to me TBH, but it's what the spec says, and it's what the conformance test suite enforces (the above test starts failing on astral-sh/ruff#20368)

[erictraut]

It's quite surprising to me TBH

When we were working on that part of the spec, we wanted to ensure that any callable signature that could be described using the Callable special form could also be described using a callback protocol. With the Callable special form, it's possible to express Callable[Concatenate[int, ...], None] which describes a callable with a position-only int parameter plus a gradual form for additional parameters. If you want to express the same signature using a callback protocol, you can use def __call__(self, x: int, /, *args: Any, **kwargs: Any) -> None: ....

[AlexWaygood]

Thanks @erictraut, that makes a lot of sense!