Narrowing and exhaustiveness errors when matching on a tuple of optionals

[linabutler]

Bug Report

When using match on a tuple of optionals, Mypy doesn't seem to:

1. Narrow the type from Optional[T] to T in non-optional cases, even if all the None cases have been handled.
2. Recognize that the match is exhaustive.

This feels similar to #12267 (comment), or maybe #12364 or #13989, but the example is a little different; apologies if it's a dupe / already known—and thanks for taking a look!

To Reproduce

https://mypy-play.net/?mypy=latest&python=3.11&gist=b6c10a27006d7b5ad55729467c2c5de8

Expected Behavior

No errors. 😊

I've used this match-on-a-tuple pattern in Rust and Swift a few times, which is why I was a little surprised that Mypy didn't like it.

Actual Behavior

main.py:4: error: Missing return statement  [return]
main.py:9: error: Item "None" of "Optional[str]" has no attribute "encode"  [union-attr]

Your Environment

• Mypy version used: 1.0.0
• Python version used: 3.11

[bluenote10]

For some reason the link to mypy playground is currently giving me an error Failed to fetch the gist: AxiosError: Request failed with status code 403.

Is this issue e.g. about the following?

def foo(a: str | None, b: str | None) -> None:
    match a, b:
        case None, None:
            return
        case a_matched, None:
            reveal_type(a_matched)
            return
        case None, b_matched:
            reveal_type(b_matched)
            return        
        case a_matched, b_matched:
            reveal_type(a_matched)
            reveal_type(b_matched)
            return   

The revealed types are:

main.py:10: note: Revealed type is "Union[builtins.str, None, builtins.str, None]"
main.py:13: note: Revealed type is "Union[builtins.str, None, builtins.str, None]"
main.py:16: note: Revealed type is "Union[builtins.str, None, builtins.str, None]"
main.py:17: note: Revealed type is "Union[builtins.str, None, builtins.str, None]"

and I was wondering if this is supposed to infer non-optional value even without explicit guards.

Using explicit guards seems to work in this case, but it is syntactically more clumsy than an if elif chain that there is almost no practical reason to use match.

def foo(a: str | None, b: str | None) -> None:
    match a, b:
        case None, None:
            return
        case (a_matched, None) if a_matched is not None:
            reveal_type(a_matched)
            return
        case (None, b_matched) if b_matched is not None:
            reveal_type(b_matched)
            return        
        case (a_matched, b_matched) if a_matched is not None and b_matched is not None:
            reveal_type(a_matched)
            reveal_type(b_matched)
            return