else not considered unreachable when if type binder should always match

[jivid]

I believe this is either a bug or I'm missing something very obvious

I am trying to add type hints to a function that takes as input either a list of strings, or a set of strings, performs a transformation on every element of the input, and returns an object of the same type as the input. A contrived example is:

def make_upper(i):
    args = [a.upper() for a in i]
    
    if isinstance(i, set):
        return set(args)
    else:
        return args

With type hints, I've arrived at:

T = TypeVar("T", List[str], Set[str])

def make_upper(i: T) -> T:
    args = [a.upper() for a in i]
    
    if isinstance(i, set):
        return set(args)
    else:
        return args

However, this results in mypy throwing an error main.py:11: error: Incompatible return value type (got "List[str]", expected "Set[str]"). The error is thrown on the return args line.

What is confusing me even more, is if I change the code to this:

T = TypeVar("T", List[str], Set[str])

def make_upper(i: T) -> T:
    args = [a.upper() for a in i]
    
    if isinstance(i, list):
        return args
    else:
        return set(args)

I get the inverse error main.py:11: error: Incompatible return value type (got "Set[str]", expected "List[str]") on the return set(args) line.

I went with a TypeVar instead of Union since the input type is preserved in the output and so a generic fit better, rather than needing to always cast() the return type in the caller code

[emmatyping]

I believe you want to use overloads.

With a TypeVar, mypy will try the types you pass for that TypeVar, which is not what you want (the error swaps because it tries List[str] then Set[str], so one will work, then the other won't, or visa-versa).

You want something like:

@overload
def make_upper(i: Set[str]) -> Set[str]: ...
    
@overload
def make_upper(i: List[str]) -> List[str]: ...

def make_upper(i: Union[Set[str], List[str]]) -> Union[Set[str], List[str]]:
    args = [a.upper() for a in i]
    
    if isinstance(i, set):
        return set(args)
    else:
        return args

[jivid]

Thanks for the response @ethanhs.

I'm a bit confused at the suggestion since PEP484 mentions constrained TypeVar as being roughly equivalent to @overload. I can't deep link into the PEP so quoting it below:

A constrained TypeVar type can often be used instead of using the @overload decorator. For example, the definitions of concat1 and concat2 in this stub file are equivalent:

from typing import TypeVar, Text

AnyStr = TypeVar('AnyStr', Text, bytes)

def concat1(x: AnyStr, y: AnyStr) -> AnyStr: ...

@overload
def concat2(x: str, y: str) -> str: ...
@overload
def concat2(x: bytes, y: bytes) -> bytes: ...

What's the difference between the example in the PEP and what I'm trying to do?

[msullivan]

I think you are right and this is a mypy bug.
It looks like mypy's control flow analysis doesn't consider an else branch to be unreachable if the if branch should be always reachable. This means that when checking the function with T = Set[str], it doesn't realize that it shouldn't check the else branch since it can't be taken.

The following code should work:

def make_upper(i: T) -> T:
    args = [a.upper() for a in i]

    if isinstance(i, set):
        return set(args)
    elif isinstance(i, set):
        return args
    assert False, "unexpected argument type!"

[erictraut]

This bug appears to have been fixed. The latest version of mypy doesn't emit any errors for the original code sample (using a constrained TypeVar) or the suggested workaround (using overloads).