Confusing error message when using AnyStr

[oconnor663]

from typing import AnyStr

def f(x: AnyStr, y: AnyStr) -> AnyStr:
    print(x + y)

f('one', b'two')

This correctly fails to typecheck because the second arg is bytes, but the error message is hard to follow:

test.py:6: error: Type argument 1 of "f" has incompatible value "object"

[JukkaL]

The error message is pretty confusing and this has came up before. I think Guido gave a talk about typing that happened to have this message as an example which was a little awkward as it's so opaque :-/

A better message would show all argument types and enumerate all the valid signatures. A similar thing should be done for overloaded functions.

Potential error message (we should iterate on this):

test.py:6: error: Invalid argument types for "f" (str, bytes)
test.py:6: note: Valid argument types for "f":
test.py:6: note:   (str, str)
test.py:6: note:   (bytes, bytes)

This gets a little complicated if there are keyword arguments, etc.

Maybe we could point to the definition of f as well.

[JukkaL]

What about including this in a milestone, now that we've been improving error messages? This must be one of the worst error messages users will commonly encounter.

[quartox]

I will look into this.

[OddBloke]

For reference, this now outputs:

963.py:6: error: Value of type variable "AnyStr" of "f" cannot be "object"

which does direct the user towards the problem a little more; the confusing reference to "object" is still present.

[OddBloke]

Also, this:

from typing import AnyStr

class One(str):
    pass

class Two(str):
    pass

OneTwo = TypeVar('OneTwo', One, Two)

def g(x: OneTwo, y: OneTwo) -> None:
    print(x + y)

g(One('a'), Two('b'))

does not resolve to object as the invalid value:

963.py:14: error: Value of type variable "OneTwo" of "g" cannot be "str"

[JelleZijlstra]

Currently this outputs:

main.py:3: error: Missing return statement
main.py:6: error: Value of type variable "AnyStr" of "f" cannot be "Sequence[object]"

which is arguably worse. I think this is another entry for the topic-join-v-union Using join vs. using unions list: if we inferred a union instead of a join here, the error message would say something like Value of type variable "AnyStr" of "f" cannot be "Union[bytes, str]", which is much better.

For comparison pyright says:

Argument of type "Literal[b'two']" cannot be assigned to parameter "y" of type "AnyStr@f" in function "f"
  Type "bytes" is incompatible with constrained type variable "str"