Add subtyping / assignability between callable types and classes

[dhruvmanila]

Some other false positives appear to be because we lack handling of assignability/subtyping of a class literal or subclass-of type to a Callable type. I think the proper handling here (barring metaclass __call__ handling) would consider the class to be an intersection of its __init__ and __new__ signatures. But we could also do a temporary version that just uses the current Type::signatures() implementation as forgiving gradual callable.

Originally posted in astral-sh/ruff#16512 (comment)

This involves adding subtyping and assignability between:

• CallableType and Type::ClassLiteral (high priority)
• CallableType and Type::Instance (class instance with __call__ method)
• CallableType and Type::SubclassOf
• CallableType and Type::GenericAlias

[carljm]

Subtyping/assignability between CallableType and SubclassOf is unsound (because no Liskov enforcement on constructors), but we probably should do it anyway. I'd at least like a TODO comment to note that it's unsound so in future we can consider an opt-in option to disable it.

[dhruvmanila]

This seems like a pretty high priority because it shows up a lot in the ecosystem changes in astral-sh/ruff#17366, specifically between callable types and class literals.

[sharkdp]

Another thing that would solve a lot of false positives would be assignability of instances of classes with a __call__ method to a Callable type. For example, I see a lot of false positives on usages of functools.partial:

from typing import Callable
from functools import partial

def f(x: int, y: str) -> None: ...

c: Callable[[int], None] = partial(f, y="a")

(https://types.ruff.rs/9f32b840-e3bd-42dd-8dea-14136e1eb6c4)

[dhruvmanila]

Another thing that would solve a lot of false positives would be assignability of instances of classes with a __call__ method to a Callable type.

I think we have that but it's only for is_subtype_of, we would need to add it to is_assignable_to as well.

https://github.com/astral-sh/ruff/blob/e7f38fe74ba642cbd4cf286d8524f4172cbe30e2/crates/red_knot_python_semantic/src/types.rs#L1231-L1239

This seems a bit unfortunate that we need to duplicate this in both is_subtype_of and is_assignable_to because the match arm in is_subtype_of would only work for fully static type and partial's __call__ method is gradual:

https://github.com/python/typeshed/blob/87f599dc8312ac67b941b5f2b47274534a1a2d3a/stdlib/functools.pyi#L118-L127

So, this seems like an easy fix?

[sharkdp]

Okay, thank you for the references, I can look into it.

[carljm]

This is another point in favor of the idea that we should collapse is_subtype_of and is_assignable_to into a single implementation with a strategy parameter.

[dhruvmanila]

Progress on assignability between Callable and ClassLiteral:

• [red-knot] Add basic subtyping between class literal and callable ruff#17469
• [red-knot] Class literal __new__ function callable subtyping ruff#17533
• [ty] Add subtyping between Callable types and class literals with __init__ ruff#17638