Changed callable to return TypeIs[Callable] rather than TypeIs[Callable[..., object]]

[randolf-scholz]

Fixes #16050

[AlexWaygood]

you can fix the pyright issues by using TypeIs[Callable[..., Any]] rather than TypeIs[Callable] here. It means the same thing as TypeIs[Callable] but is more explicit and will satisfy pyright in strict mode.

But it's unclear to me why this change is desirable. I don't really agree that type checkers are correct in narrowing an object to Callable[..., Any] after an isinstance(x, Callable) check. ty currently narrows the type to Top[Callable[..., object]] after an isinstance(x, Callable) check, which is possibly too strict, but requiring additional narrowing checks before you permit arbitrary operations on the object returned by the callable seems reasonable to me

[randolf-scholz]

Well, I would say there are 2 motivations:

1. I want if isinstance(arg, Callable): and if callable(arg): to produce identical narrowing. Whether or not thats Callable[..., Any] or Callable[..., object] is a second order concern.

2. I can see the motivation why one would want to infer object rather than Any/Unknown, but I do not see why one should special case that only for callable in particular. Consider:

from typing import reveal_type
from collections.abc import Iterable

def check(arg: object) -> None:
    if isinstance(arg, Iterable):
        reveal_type(arg)
        reveal_type(next(iter(arg)))

Here all the type checkers, except ty, say it's Iterable[Any] / Iterable[unknown] as well. Hence, I don't believe it makes sense to single out and special case callable in typeshed. One could consider making all the standard covariant containers default to object, but maybe one should leave that to the type checker vendors.

[randolf-scholz]

Oh, and wrt to the last point, my idea with using TypeIs[Callable] rather than TypeIs[Callable[..., Any]] was exactly that, if a type checker like ty decided to treat Callable as class Callable[**P, R=object] rather than class Callable[**P, R], then callable would inherit that behavior automatically with TypeIs[Callable], but with Typeis[Callable[..., Any]] it would force the Any inference.

[github-actions]

According to mypy_primer, this change has no effect on the checked open source code. 🤖🎉