[red-knot] Check gradual equivalence between callable types

[dhruvmanila]

Summary

Part of #15382

Add support for checking the gradual equivalence between callable types.

A callable type is gradually equivalent to the other callable type:

• Both uses gradual form for the parameters. If not, then the number of parameters should be the same and the type at the a position in the first parameter list should be gradually equivalent the the type at the same position in the second parameter list
• Both the return types are either None or the some values are gradually equivalent to each other.

Test Plan

Update is_gradual_equivalent_to.md with callable type test cases.

Note: I've an explicit goal of updating the property tests with the new callable types once all relations are implemented.

[github-actions]

mypy_primer results

No ecosystem changes detected ✅

[sharkdp]

Apart for the one question I had, this looks good to me. Thank you.

[carljm]

Looks good! I guess this (and the other similar PRs) will probably need some adjustment rebased on top of @dcreager's overload support.

[carljm]

Looks great!

[dhruvmanila]

I found one more case which we need to consider:

def foo(*args: Any, **kwargs: Any) -> Any:
    pass

static_assert(is_gradual_equivalent_to(CallableTypeFromFunction[foo], Callable[..., Any]))

Because, as per the spec:

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 ....

https://typing.python.org/en/latest/spec/callables.html#meaning-of-in-callable

[dhruvmanila]

Oh, that's simple to fix. I don't need to explicitly check whether both signatures has is_gradual flag as true because even in the case of ..., the parameters is populated with *Any, **Any.