Skip to content

Inconsistent "Incompatible return type" error when List[int] is returned for List[Union[str, int]] when layered up with Tuple/Union #17868

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
huntfx opened this issue Oct 2, 2024 · 0 comments
Labels
bug mypy got something wrong topic-type-context Type context / bidirectional inference

Comments

@huntfx
Copy link

huntfx commented Oct 2, 2024

Bug Report

When layering up some Union/Tuple checks, at some point the type checking suddenly gets a lot more strict and starts failing, as if it's unable to fully parse the type checks anymore.

It's possibly related to this, but it doesn't explain why the behaviour changes only once it's wrapped under other things: #3351

To Reproduce

Here's a minimal reproducible example that shows how it works fine until it suddenly doesn't.

from typing import Union, Tuple, List

# Just to reduce the noise
S = Union[int, str]
L = List[S]

# It works with `([int],)`
def func_works1() -> Tuple[L]:
    return [1],
    
# It works with `([int, str],)`
def func_works2() -> Tuple[L]:
    return [1, 'a'],

# It works with `int | [int]`
def func_works3() -> Union[S, L]:
    return [1]

# It works with `(int,) | ([int],)` if returning (int,)
def func_works4() -> Union[Tuple[S], Tuple[L]]:
    return 1,

# It fails with `(int,) | ([int],)` if returning ([int],)
def func_fail1() -> Union[Tuple[S], Tuple[L]]:
    return [1],
main.py:21: error: Incompatible return value type (got "tuple[list[int]]", expected "tuple[int | str] | tuple[list[int | str]]")  [return-value]

# It fails with `(int,) | ([int],)` if returning ([int, str],)
def func_fail2() -> Union[Tuple[S], Tuple[L]]:
    return [1, 'a'],
main.py:25: error: Incompatible return value type (got "tuple[list[object]]", expected "tuple[int | str] | tuple[list[int | str]]")  [return-value]

https://mypy-play.net/?mypy=latest&python=3.12&gist=9477b2d4dab01919bef1aa6d2911f648

Expected Behavior

It passes the test.

Actual Behavior

In the code above. It complains that List[int] is not a valid List[Union[int | str]]. According to the issue linked above, this may not be wrong, but the behaviour is inconsistent as to when it flags it as wrong.

Your Environment

  • Mypy version used: 1.11.2
  • Mypy command-line flags: None
  • Mypy configuration options from mypy.ini (and other config files): I just run py -m mypy without any config files.
  • Python version used: 3.7, 3.11

Edit
This is nothing to do with the bug report, but in case anyone finds this issue with a similar use case, this is the fully working solution I've ended up with:

S = Union[int, str]
T = TypeVar('T', S, List[S])
FuncType = Tuple[T, T]

def func() -> FuncType:
   return a, b
@huntfx huntfx added the bug mypy got something wrong label Oct 2, 2024
@JelleZijlstra JelleZijlstra added the topic-type-context Type context / bidirectional inference label Oct 2, 2024
@huntfx huntfx changed the title Inconsistent List[int] is not a valid input for List[Union[str, int]] error when layered up with Tuple/Union Inconsistent "Incompatible return type" error when List[int] is returned for List[Union[str, int]] when layered up with Tuple/Union Oct 3, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
bug mypy got something wrong topic-type-context Type context / bidirectional inference
Projects
None yet
Development

No branches or pull requests

2 participants