Wrong "Too many arguments" errors with tuple unpacking

[torfsen]

Bug Report

I'm getting wrong or misleading "Too many arguments" errors when using tuple unpacking in function calls.

To Reproduce

from typing import Tuple

def x(x: int, y: int) -> None:
    print(x, y)

def foo1(t: tuple) -> None:
    x(*t[:1], 1)

def foo2(t: tuple) -> None:
    x(*t[:2])

def foo3(t: Tuple[int]) -> None:
    x(*t[:1], 1)

mypy reports:

$ mypy sandbox.py 
sandbox.py:7: error: Too many arguments for "x"
Found 1 error in 1 file (checked 1 source file)

(Line 7 is the call to x in foo1)

Expected Behavior

The call to x in foo1 will never have too many arguments -- it has either 1 (if t is empty) or 2 (if t is not empty). I would have expected an error regarding the possibility of t being empty (i.e. "Potentially not enough arguments").

Also I think that foo1 and foo2 share the same issues regarding their calls of x, so I would have expected to get the same errors for both of them.

Actual Behavior

The call to x in foo1 is reported, but the call to x in foo2 isn't. Interestingly, fixing the tuple length (as in foo3) seems to fix the issue.

Your Environment

• Mypy version used: 0.790
• Mypy command-line flags: None
• Mypy configuration options from mypy.ini (and other config files): None
• Python version used: 3.8.5
• Operating system and version: Ubuntu 18.04.5

[MaddyGuthridge]

This is still an issue for me. Can this get some attention so it can be fixed?

[erictraut]

The sample above uses tuple with no type arguments. That's a problem because mypy can't determine the intended length of the tuple. If you provide type arguments that specify a tuple length, you can avoid type errors.

For example, in the above sample, foo1 could be changed as follows:

def foo1(t: tuple[Any, int]) -> None:
    x(*t[:1], 1)

Mypy is arguably doing the correct thing here. If you don't like the current behavior, you are welcome to propose a different behavior and submit a PR to implement that behavior.

[MaddyGuthridge]

This example is pretty clear about the length of its tuples and it still gets errors on both return statements of the second function. It seemed that the if len(index) == n expression wasn't filtering what the tuple could be.

def my_function(a: int, b: int, c: int = 0):
    return a + b + c

def do_thing(index: 'tuple[int, int] | tuple[int]'):
    if len(index) == 1:
        return my_function(*index, 2, 3)
    elif len(index) == 2:
        return my_function(*index, 2)

do_thing((1, ))

[erictraut]

Yes, this would work if mypy were to add type narrowing support for the len(x) == y pattern. This is tracked in issue #1178.