`mypy` unable to narrow type of tuple elements in `case` clause in pattern matching

[exoriente]

Bug Report

When using match on a tuple, mypy is unable to apply type narrowing when a case clause specifies the type of the elements of the tuple.

To Reproduce

Run this code through mypy:

class MyClass:
    def say_boo(self) -> None:
        print("Boo!")


def function_without_mypy_error(x: object) -> None:
    match x:
        case MyClass():
            x.say_boo()


def function_with_mypy_error(x: object, y: int) -> None:
    match x, y:
        case MyClass(), 3:
            x.say_boo()

Expected Behavior

mypy exists with Succes.

I would expect mypy to derive the type from the case clause in the second function, just like it does in the first function. Knowing the first element of the matched tuple is of type MyClass it should allow for a call to .say_boo().

Actual Behavior

mypy returns an error:

example.py:15: error: "object" has no attribute "say_boo"

Your Environment

I made a clean environment with no flags or ini files to test the behavior of the example code given.

• Mypy version used: mypy 0.940
• Mypy command-line flags: none
• Mypy configuration options from mypy.ini (and other config files): none
• Python version used: Python 3.10.2
• Operating system and version: macOS Monterrey 12.2.1

[tmke8]

Yeah, mypy doesn't narrow on tuples. I commented on it here: #12267 (comment) But apparently the worry is that it is too computationally expensive.

EDIT: hmm, maybe it's not the same problem actually

[cpbotha]

I just ran into this exact problem in a codebase I'm converting to mypy.

I worked around the issue (for now) by adding a superfluous assert isinstance(x, MyClass) just above x.say_boo().

[alexpovel]

I believe the issue I came across fits here. For example:

from datetime import date
from typing import Optional


def date_range(
    start: Optional[date],
    end: Optional[date],
    fmt: str,
    sep: str = "-",
    ongoing: str = "present",
) -> str:
    match (start, end):
        case (None, None):  # A
            return ""
        case (None, date() as end):  # B
            return f"{sep} {end.strftime(fmt)}"  # C
        case (date() as start, None):
            return f"{start.strftime(fmt)} {sep} {ongoing}"
        case (date() as start, date() as end):
            return f"{start.strftime(fmt)} {sep} {end.strftime(fmt)}"
        case _:
            raise TypeError(f"Invalid date range: {start} - {end}")


print(date_range(date(2020, 1, 1), date(2022, 10, 13), "%Y-%m-%d"))

(This not-quite-minimal working example should run as-is).

After line A, end cannot possibly be None. mypy understands guard clauses like if a is not None: ..., after which it knows to drop None from the type union of a. So I hoped it could deduce it in this case as well, but no dice. I can see that it might introduce a lot of complexity.

To circumvent, I cast to date explicitly in line B, such that line C doesn't yield a type checking attribute error anymore (error: Item "None" of "Optional[date]" has no attribute "strftime" [union-attr]). Note that date(end) didn't work (for mypy), it had to be date() as end.

While this works and line C is then deduced correctly, the resulting code is quite verbose. I suspect checking all combinations of start and end for None is verbose in any case (before match, this would have been a forest of conditionals), but wondered if this could be solved more succinctly.

Another suspicion I have is that structural pattern matching in Python is intended more for matching to literal cases, not so much for general type checking we'd ordinarily use isinstance and friends for (?). At least that's what it looks like from PEP 636.

---

EDIT: More context here:

• https://mypy-lang.blogspot.com/2022/03/mypy-0940-released.html
• https://mypy.readthedocs.io/en/stable/literal_types.html#exhaustiveness-checking with its assert_never

[arseniiv]

I have what appears the same issue (mypy 1.2, Python 3.11):

A value of type Token: = str | tuple[Literal['define'], str, str] | tuple[Literal['include'], str] | tuple[Literal['use'], str, int, int] is matched upon in this manner:

match token:
    case str(x):
        ...
    case 'define', def_var, def_val:
        reveal_type(token)
        ...
    case 'include', inc_path:
        reveal_type(token)
        ...
    case 'use', use_var, lineno, column:
        reveal_type(token)
        ...
    case _:
        reveal_type(token)
        assert_never(token)

In each case the type revealed is the full union, without only a str which is succesfully filtered out by the first case str(x), and then there’s an error in assert_never(token) because nothing had been narrowed.

Also def_var and other match variables are all typed as object and cause errors in their own stead—but that here at least can be fixed by forcefully annotating them like str(def_var) and so on.

Also for some reason I don’t see any errors from mypy in VS Code on this file, but I see them in droves when running it myself. 🤔