Error for lambda containing Any even when type can be inferred

Using mypy 0.641 with the --disallow-any-expr flag and this sample using @overload

from typing import Callable, Tuple, TypeVar, overload

T = TypeVar('T')
A0 = TypeVar('A0')
A1 = TypeVar('A1')


@overload
def foo(
    vars: Tuple[A0],
    op: Callable[[A0], T]
) -> T: ...


@overload
def foo(
    vars: Tuple[A0, A1],
    op: Callable[[A0, A1], T]
) -> T: ...


def foo(vars, op):
    pass


def foo_not_overloaded(
    vars: Tuple[A0, A1],
    op: Callable[[A0, A1], T]
) -> T:
    pass


a = 5
b = 3

foo((a, b), lambda a, b: a - b)

produces

typist2.py:36: error: Expression type contains "Any" (has type "Callable[[Any, Any], Any]")
typist2.py:36: error: Expression has type "Any"

However mypy seems to be able to infer the type of the lambda because if I modify the last line to read

foo((a, b), lambda a, b: a - b.bad)

mypy correctly identifies that "int" has no attribute "bad", sprinkling some prints on the mypy source also reveals it figures out it's a (int, int) -> int at some point.

foo_not_overloaded checks without trouble and so does using a plain def instead of the lambda.

Comience con el reproductor proporcionado usando mypy 0.641 y compare la llamada sobrecargada a foo con foo_not_overloaded y con el caso de un def simple. Siga el tipo inferido de la lambda a través de la ruta de sobrecarga y verifique después que la lambda válida ya no desencadena errores de disallow-any-expr, mientras que la variante a - b.bad sigue informando del atributo no válido.