Incorrect errors with TypeVar + Union/overload

[drewhaven]

I'm trying to stub a function that takes different types for a base argument and then a bunch of AnyStrs. It seems that neither Union nor overload works correctly for stubbing it:

from typing import overload, AnyStr, Union

def f(x: Union[AnyStr, int], *a: AnyStr) -> None: ...

@overload
def g(x: AnyStr, *a: AnyStr) -> None: ...
@overload
def g(x: int, *a: AnyStr) -> None: ...

f('foo')
f('foo', 'bar')
f('foo', b'bar')  # correctly fails: Type argument 1 of "f" has incompatible value "object"
f(1)  # erroneously fails: error: Type argument 1 of "f" has incompatible value "int"
f(1, 'foo')  # erroneously fails: error: Type argument 1 of "f" has incompatible value "object"
f(1, 'foo', b'bar')  # correctly fails: error: Type argument 1 of "f" has incompatible value "object"

g('foo')
g('foo', 'bar')
g('foo', b'bar')  # correctly fails: error: Type argument 1 of "g" has incompatible value "object"
g(1)
g(1, 'foo')  # erroneously fails: error: Type argument 1 of "g" has incompatible value "object"
g(1, 'foo', b'bar')  # correctly fails: Type argument 1 of "g" has incompatible value "object"

[JukkaL]

Ah, there seem to be two issues.

1. We sometimes fail to infer a valid value for AnyStr if it's as part of a union in a type signature (f in your example).

2. Overload resolution when using type variables with value restriction is broken.

[gvanrossum]

Oh hai Reid! :-)

[rwbarton]

@overload
def g(x: AnyStr, *a: AnyStr) -> None: ...
@overload
def g(x: int, *a: AnyStr) -> None: ...

g('foo', b'bar')  # correctly fails: error: Type argument 1 of "g" has incompatible value "object"

It's correct that the call fails, but actually the first overload shouldn't match, right? AnyStr is a type variable with value restriction, so all of the AnyStrs need to be replaced with the same type, either str or bytes. It doesn't matter in this case (aside from the error message), but if there was a later overload that matched [str, bytes], it would (a) be considered non-overlapping, and (b) match this call.

[JukkaL]

Overloading used to be implemented as dynamic dispatch based on argument types. Mypy still uses erased types to determine which overload matches, as that's the only thing that was easily available for runtime dispatch. Type variables are erased to object so they always match.

Here are potentially better approaches:

1. Perform full type inference when picking overload target. (We may want to reuse the results in later phases of type checking the call, since otherwise we'd be doing a lot of redundant work.)
2. Erase a type variable with a value restriction to a union type. This would be easier than 1 and would still solve the original problem. This would only require changes to overload_arg_similarity in checkexpr.py, I think.

[rwbarton]

Another alternative is: 3. Replace an overload item involving one or more type variables with value restrictions by all the types obtained by substituting all combinations of those values into the original type (like in expand_typevars). That has the potential advantage of retaining the relationship between repeated instances of a type variable in a type.

I'll just go with option 2 for now since it is simple, and we can keep option 3 as a possible wishlist item, if we don't decide to implement option 1 first.