Inference on simple list comprehension type not working

[alkamid]

This is a feature request.

from typing import Tuple
def test_1(inp1: Tuple[int, int, int]) -> None:
    pass

def test_2(inp2: Tuple[int, int, int]) -> None:
    test_tuple = tuple(e for e in inp2)
    reveal_type(test_tuple)
    test_1(test_tuple)

The code above, when run with mypy 0.590 (no flags) and Python 3.6, results in:

mypytest.py:7: error: Revealed type is 'builtins.tuple[builtins.int*]'
mypytest.py:8: error: Argument 1 to "test_1" has incompatible type "Tuple[int, ...]"; expected "Tuple[int, int, int]"

I appreciate that the types inside a list comprehension are not trivial to infer, but maybe mypy could at least handle a case where there are no operations on the elements, and I'm looping through all elements, as shown above? The expected type of test_tuple would then be builtins.tuple[builtins.int, builtins.int, builtins.int].

[ilevkivskyi]

This is hard to implement, you might want to just use a cast in your code.

[amcgregor]

Additional sample case, enumerating generic plugins.

Flags = Set[str]

provided: Flags = set().union(*(traverse(ext, 'provides', ()) for ext in extensions))

Results in: Incompatible types in assignment (expression has type "Set[<nothing>]", variable has type "Set[str]").

As the developer, I'm conscious of the fact that (with properly written extensions) every provides attribute will be a set of string flags. Mypy is not aware of this, and I'm extremely hesitant to add imperative code to invoke cast on every invocation of my own function—sure, it just returns the value passed in, but that actually represents stack frame allocation, population/setup, invocation, then teardown. Yuck!

(I'll do it, as it seems I have no other choice, but yuck.)

[cmekik]

I think this is another example case, with workaround.

from typing import Set, Union

s_input: Set[Union[str, int]] = {"a str", 1, 2} # heterogeneous input
s_ref: Set[int] = {1, 2, 3} # reference set

# error: Generator has incompatible item type "Union[str, int]"; expected "int"
s_filtered_1: Set[int] = set(x for x in s_input if x in s_ref)

# OK; workaround
s_filtered_2: Set[int] = set(x for x in s_ref if x in s_input)

[hauntsaninja]

@cmekik 's example is expected, mypy doesn't do type narrowing based on collection membership:

x: Union[int, str]
y: List[str]

if x in y:
    reveal_type(x)

@amcgregor 's example has a slightly nicer workaround than cast: use Set[str]().union(...)

Both are unrelated to the original example, where the issue is that mypy isn't too intelligent about tuple lengths.