mypy's narrowing for match statements sometimes fails when the subject of the match is a function call

[zenbot]

Bug Report

mypy's narrowing for match statements sometimes fails when the subject of the match is a function call.

To Reproduce

from typing_extensions import assert_never

def fn() -> int | None:
    ...

match fn(): 
    case int():
        pass
    case None:
        pass
    case _ as unreachable:
        assert_never(unreachable)

Expected Behavior

The code above should pass a type check because case statements handle all possible return values of fn().

Actual Behavior

$ mypy --strict bad.py
bad.py:12: error: Argument 1 to "assert_never" has incompatible type "Optional[int]"; expected "NoReturn"
Found 1 error in 1 file (checked 1 source file)

Note

Assigning the return value of fn() to a variable and using that variable as the subject of the match does pass type checking:

from typing_extensions import assert_never

def fn() -> int | None:
    ...

rv = fn()

match rv: 
    case int():
        pass
    case None:
        pass
    case _ as unreachable:
        assert_never(unreachable)

Handling all cases within the one case statement also passes type checking:

from typing_extensions import assert_never

def fn() -> int | None:
    ...

match fn(): 
    case int() | None:
        pass
    case _ as unreachable:
        assert_never(unreachable)

mypy's output for both of the above:

$ mypy --strict bad.py
Success: no issues found in 1 source file

Your Environment

• Mypy version used: mypy 0.961 (compiled: yes)
• Mypy command-line flags: --strict
• Python version used: Python 3.10
• Operating system and version: macOS Monterey 12.3.1

[Corwinpro]

Potential workaround (yet this is certainly a bug):

match value := fn():
    ... 

Overall, I think the problem is with Callable:

def foo(f: Callable[[], Result[int, str]]) -> str:
    match f():  # does not work, mypy complains
        case Ok(value):
            return f"{value}"
        case Err(e):
            raise RuntimeError(e)

but this is OK:

def foo(f: Callable[[], Result[int, str]]) -> str:
    value = f()
    match value:  # does work, mypy is happy
        case Ok(value):
            return f"{value}"
        case Err(e):
            raise RuntimeError(e)

[bwo]

Something similar seems to happen with tuples. Mypy doesn't like this:

def foo(i: int | str, j : int | str) -> int:
    match (i, j):
        case int(), int(): return i + j
        case int(), str(): return i + len(j)
        # and so on

But this is fine:

def foo(i: int | str, j : int | str) -> int:
    t = (i, j)
    match t:
        case int(), int(): return t[0] + t[1]
        case int(), str(): return t[0] + len(t[1])
    # and so on

however, even in the latter case, you can't put an assert_never(t) at the end.

[hauntsaninja]

Btw, I'm curious if any of the folks on this thread are encountering this in open source projects. I'd love to add more coverage for match statement to mypy_primer