-- Capture Pattern --

[case testMatchCapturePatternType]

# flags: --strict-equality --warn-unreachable

class A: ...

m: A

match m:

case a:

reveal_type(a) # N: Revealed type is "__main__.A"

-- Literal Pattern --

[case testMatchLiteralPatternNarrows]

# flags: --strict-equality --warn-unreachable

m: object

match m:

case 1:

reveal_type(m) # N: Revealed type is "Literal[1]"

case 2:

reveal_type(m) # N: Revealed type is "Literal[2]"

case other:

reveal_type(other) # N: Revealed type is "builtins.object"

[case testMatchLiteralPatternNarrows2]

# flags: --strict-equality --warn-unreachable

from typing import Any

m: Any

match m:

case 1:

reveal_type(m) # N: Revealed type is "Any"

case 2:

reveal_type(m) # N: Revealed type is "Any"

case other:

reveal_type(other) # N: Revealed type is "Any"

[case testMatchLiteralPatternBoolIntAlreadyNarrower]

# flags: --strict-equality --warn-unreachable

def foo(m: bool, x: int):

match m:

case 1:

reveal_type(m) # N: Revealed type is "Literal[1]"

match m:

case x:

reveal_type(m) # N: Revealed type is "builtins.bool"

[builtins fixtures/primitives.pyi]

[case testMatchLiteralPatternUnreachable]

# flags: --strict-equality --warn-unreachable

m: int

match m:

case "str":

reveal_type(m) # E: Statement is unreachable

[builtins fixtures/primitives.pyi]

-- Value Pattern --

[case testMatchValuePatternNarrows]

# flags: --strict-equality --warn-unreachable

import b

m: object

match m:

case b.b:

reveal_type(m) # N: Revealed type is "builtins.int"

[file b.py]

b: int

[case testMatchValuePatternAlreadyNarrower]

# flags: --strict-equality --warn-unreachable

import b

m: bool

match m:

case b.b:

reveal_type(m) # N: Revealed type is "builtins.bool"

[file b.py]

b: int

[case testMatchValuePatternIntersect]

# flags: --strict-equality --warn-unreachable

import b

class A: ...

def f(m: A) -> None:

match m:

case b.b:

reveal_type(m) # E: Statement is unreachable

[file b.py]

class B: ...

b: B

[case testMatchValuePatternUnreachable]

# flags: --strict-equality --warn-unreachable

import b

def f(m: int) -> None:

match m:

case b.b:

reveal_type(m) # E: Statement is unreachable

[file b.py]

b: str

[builtins fixtures/primitives.pyi]

-- Sequence Pattern --

[case testMatchSequencePatternCaptures]

# flags: --strict-equality --warn-unreachable

from typing import List

m: List[int]

match m:

case [a]:

reveal_type(a) # N: Revealed type is "builtins.int"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternCapturesStarred]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: Sequence[int]

match m:

case [a, *b]:

reveal_type(a) # N: Revealed type is "builtins.int"

reveal_type(b) # N: Revealed type is "builtins.list[builtins.int]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternNarrowsInner]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: Sequence[object]

match m:

case [1, True]:

reveal_type(m) # N: Revealed type is "typing.Sequence[builtins.int]"

[case testMatchSequencePatternNarrowsOuter]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: object

match m:

case [1, True]:

reveal_type(m) # N: Revealed type is "typing.Sequence[builtins.int]"

[case testMatchSequencePatternAlreadyNarrowerInner]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: Sequence[bool]

match m:

case [1, True]:

reveal_type(m) # N: Revealed type is "typing.Sequence[builtins.bool]"

[case testMatchSequencePatternAlreadyNarrowerOuter]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: Sequence[object]

match m:

case [1, True]:

reveal_type(m) # N: Revealed type is "typing.Sequence[builtins.int]"

[case testMatchSequencePatternAlreadyNarrowerBoth]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: Sequence[bool]

match m:

case [1, True]:

reveal_type(m) # N: Revealed type is "typing.Sequence[builtins.bool]"

[case testMatchNestedSequencePatternNarrowsInner]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: Sequence[Sequence[object]]

match m:

case [[1], [True]]:

reveal_type(m) # N: Revealed type is "typing.Sequence[typing.Sequence[builtins.int]]"

[case testMatchNestedSequencePatternNarrowsOuter]

# flags: --strict-equality --warn-unreachable

from typing import Sequence

m: object

match m:

case [[1], [True]]:

reveal_type(m) # N: Revealed type is "typing.Sequence[typing.Sequence[builtins.int]]"

[case testMatchSequencePatternDoesntNarrowInvariant]

# flags: --strict-equality --warn-unreachable

from typing import List

m: List[object]

match m:

case [1]:

reveal_type(m) # N: Revealed type is "builtins.list[builtins.object]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternMatches]

# flags: --strict-equality --warn-unreachable

import array, collections

from typing import Sequence, Iterable

m1: object

m2: Sequence[int]

m3: array.array[int]

m4: collections.deque[int]

m5: list[int]

m6: memoryview

m7: range

m8: tuple[int]

m9: str

m10: bytes

m11: bytearray

match m1:

case [a]:

reveal_type(a) # N: Revealed type is "builtins.object"

match m2:

case [b]:

reveal_type(b) # N: Revealed type is "builtins.int"

match m3:

case [c]:

reveal_type(c) # N: Revealed type is "builtins.int"

match m4:

case [d]:

reveal_type(d) # N: Revealed type is "builtins.int"

match m5:

case [e]:

reveal_type(e) # N: Revealed type is "builtins.int"

match m6:

case [f]:

reveal_type(f) # N: Revealed type is "builtins.int"

match m7:

case [g]:

reveal_type(g) # N: Revealed type is "builtins.int"

match m8:

case [h]:

reveal_type(h) # N: Revealed type is "builtins.int"

match m9:

case [i]:

reveal_type(i) # E: Statement is unreachable

match m10:

case [j]:

reveal_type(j) # E: Statement is unreachable

match m11:

case [k]:

reveal_type(k) # E: Statement is unreachable

[builtins fixtures/primitives.pyi]

[typing fixtures/typing-full.pyi]

[case testMatchSequencePatternCapturesTuple]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[int, str, bool]

match m:

case [a, b, c]:

reveal_type(a) # N: Revealed type is "builtins.int"

reveal_type(b) # N: Revealed type is "builtins.str"

reveal_type(c) # N: Revealed type is "builtins.bool"

reveal_type(m) # N: Revealed type is "tuple[builtins.int, builtins.str, builtins.bool]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternTupleTooLong]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[int, str]

match m:

case [a, b, c]:

reveal_type(a) # E: Statement is unreachable

reveal_type(b)

reveal_type(c)

[builtins fixtures/list.pyi]

[case testMatchSequencePatternTupleTooShort]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[int, str, bool]

match m:

case [a, b]:

reveal_type(a) # E: Statement is unreachable

reveal_type(b)

[builtins fixtures/list.pyi]

[case testMatchSequencePatternTupleNarrows]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[object, object]

match m:

case [1, "str"]:

reveal_type(m) # N: Revealed type is "tuple[Literal[1], Literal['str']]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternTupleStarred]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[int, str, bool]

match m:

case [a, *b, c]:

reveal_type(a) # N: Revealed type is "builtins.int"

reveal_type(b) # N: Revealed type is "builtins.list[builtins.str]"

reveal_type(c) # N: Revealed type is "builtins.bool"

reveal_type(m) # N: Revealed type is "tuple[builtins.int, builtins.str, builtins.bool]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternTupleStarredUnion]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[int, str, float, bool]

match m:

case [a, *b, c]:

reveal_type(a) # N: Revealed type is "builtins.int"

reveal_type(b) # N: Revealed type is "builtins.list[builtins.str | builtins.float]"

reveal_type(c) # N: Revealed type is "builtins.bool"

reveal_type(m) # N: Revealed type is "tuple[builtins.int, builtins.str, builtins.float, builtins.bool]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternTupleStarredTooShort]

# flags: --strict-equality --warn-unreachable

from typing import Tuple

m: Tuple[int]

reveal_type(m) # N: Revealed type is "tuple[builtins.int]"

match m:

case [a, *b, c]:

reveal_type(a) # E: Statement is unreachable

reveal_type(b)

reveal_type(c)

[builtins fixtures/list.pyi]

[case testMatchNonMatchingSequencePattern]

# flags: --strict-equality --warn-unreachable

from typing import List

x: List[int]

match x:

case [str()]:

pass

[case testMatchSequencePatternWithTypeObject]

# flags: --strict-equality --warn-unreachable

class Example:

__match_args__ = ("value",)

def __init__(self, value: str) -> None:

self.value = value

SubClass: type[Example]

match [SubClass("a"), SubClass("b")]:

case [SubClass(value), *rest]:

reveal_type(value) # N: Revealed type is "builtins.str"

reveal_type(rest) # N: Revealed type is "builtins.list[__main__.Example]"

[builtins fixtures/tuple.pyi]

# Narrowing union-based values via a literal pattern on an indexed/attribute subject

# -------------------------------------------------------------------------------

# Literal patterns against a union of types can be used to narrow the subject

# itself, not just the expression being matched. Previously, the patterns below

# failed to narrow the `d` variable, leading to errors for missing members; we

# now propagate the type information up to the parent.

[case testMatchNarrowingUnionTypedDictViaIndex]

# flags: --strict-equality --warn-unreachable

from typing import Literal, TypedDict

class A(TypedDict):

tag: Literal["a"]

name: str

class B(TypedDict):

tag: Literal["b"]

num: int

d: A | B

match d["tag"]:

case "a":

reveal_type(d) # N: Revealed type is "TypedDict('__main__.A', {'tag': Literal['a'], 'name': builtins.str})"

reveal_type(d["name"]) # N: Revealed type is "builtins.str"

case "b":

reveal_type(d) # N: Revealed type is "TypedDict('__main__.B', {'tag': Literal['b'], 'num': builtins.int})"

reveal_type(d["num"]) # N: Revealed type is "builtins.int"

[typing fixtures/typing-typeddict.pyi]

[case testMatchNarrowingUnionClassViaAttribute]

# flags: --strict-equality --warn-unreachable

from typing import Literal

class A:

tag: Literal["a"]

name: str

class B:

tag: Literal["b"]

num: int

d: A | B

match d.tag:

case "a":

reveal_type(d) # N: Revealed type is "__main__.A"

reveal_type(d.name) # N: Revealed type is "builtins.str"

case "b":

reveal_type(d) # N: Revealed type is "__main__.B"

reveal_type(d.num) # N: Revealed type is "builtins.int"

[case testMatchSequenceUnion]

# flags: --strict-equality --warn-unreachable

from typing import List, Union

m: Union[List[List[str]], str]

match m:

case [list(['str'])]:

reveal_type(m) # N: Revealed type is "builtins.list[builtins.list[builtins.str]]"

[builtins fixtures/list.pyi]

[case testMatchSequencePatternNarrowSubjectItems]

# flags: --strict-equality --warn-unreachable

m: int

n: str

o: bool

match m, n, o:

case [3, "foo", True]:

reveal_type(m) # N: Revealed type is "Literal[3]"

reveal_type(n) # N: Revealed type is "Literal['foo']"

reveal_type(o) # N: Revealed type is "Literal[True]"

case [a, b, c]:

reveal_type(m) # N: Revealed type is "builtins.int"

reveal_type(n) # N: Revealed type is "builtins.str"

reveal_type(o) # N: Revealed type is "builtins.bool"

reveal_type(m) # N: Revealed type is "builtins.int"

reveal_type(n) # N: Revealed type is "builtins.str"

reveal_type(o) # N: Revealed type is "builtins.bool"

[builtins fixtures/tuple.pyi]

[case testMatchSequencePatternNarrowSubjectItemsRecursive]

# flags: --strict-equality --warn-unreachable

m: int

n: int

o: int

p: int

q: int

r: int

match m, (n, o), (p, (q, r)):

case [0, [1, 2], [3, [4, 5]]]:

reveal_type(m) # N: Revealed type is "Literal[0]"

reveal_type(n) # N: Revealed type is "Literal[1]"

reveal_type(o) # N: Revealed type is "Literal[2]"

reveal_type(p) # N: Revealed type is "Literal[3]"

reveal_type(q) # N: Revealed type is "Literal[4]"

reveal_type(r) # N: Revealed type is "Literal[5]"

[builtins fixtures/tuple.pyi]

[case testMatchSequencePatternSequencesLengthMismatchNoNarrowing]

# flags: --strict-equality --warn-unreachable

m: int

n: str

o: bool

match m, n, o:

case [3, "foo"]:

pass # E: Statement is unreachable

case [3, "foo", True, True]:

pass # E: Statement is unreachable

[builtins fixtures/tuple.pyi]

[case testMatchSequencePatternSequencesLengthMismatchNoNarrowingRecursive]

# flags: --strict-equality --warn-unreachable

m: int

n: int

o: int

match m, (n, o):

case [0]:

pass # E: Statement is unreachable

case [0, 1, [2]]:

pass # E: Statement is unreachable

case [0, [1]]:

pass # E: Statement is unreachable

case [0, [1, 2, 3]]:

pass # E: Statement is unreachable

[builtins fixtures/tuple.pyi]

-- Mapping Pattern --

[case testMatchMappingPatternCaptures]

# flags: --strict-equality --warn-unreachable

from typing import Dict

import b

m: Dict[str, int]

match m:

case {"key": v}:

reveal_type(v) # N: Revealed type is "builtins.int"

case {b.b: v2}:

reveal_type(v2) # N: Revealed type is "builtins.int"

[file b.py]

b: str

[builtins fixtures/dict.pyi]

[case testMatchMappingPatternCapturesWrongKeyType]

# flags: --strict-equality --warn-unreachable

# This is not actually unreachable, as a subclass of dict could accept keys with different types

from typing import Dict

import b

m: Dict[str, int]

match m:

case {1: v}:

reveal_type(v) # N: Revealed type is "builtins.int"

case {b.b: v2}:

reveal_type(v2) # N: Revealed type is "builtins.int"

[file b.py]

b: int

[builtins fixtures/dict.pyi]

[case testMatchMappingPatternCapturesTypedDict]

# flags: --strict-equality --warn-unreachable

from typing import TypedDict

class A(TypedDict):

a: str

b: int

m: A

match m:

case {"a": v}:

reveal_type(v) # N: Revealed type is "builtins.str"

case {"b": v2}:

reveal_type(v2) # N: Revealed type is "builtins.int"

case {"a": v3, "b": v4}:

reveal_type(v3) # N: Revealed type is "builtins.str"

reveal_type(v4) # N: Revealed type is "builtins.int"

case {"o": v5}:

reveal_type(v5) # N: Revealed type is "builtins.object"

[typing fixtures/typing-typeddict.pyi]

[case testMatchMappingPatternCapturesTypedDictWithLiteral]

# flags: --strict-equality --warn-unreachable

from typing import TypedDict

import b

class A(TypedDict):

a: str

b: int

m: A

match m:

case {b.a: v}:

reveal_type(v) # N: Revealed type is "builtins.str"

case {b.b: v2}:

reveal_type(v2) # N: Revealed type is "builtins.int"

case {b.a: v3, b.b: v4}:

reveal_type(v3) # N: Revealed type is "builtins.str"

reveal_type(v4) # N: Revealed type is "builtins.int"

case {b.o: v5}:

reveal_type(v5) # N: Revealed type is "builtins.object"

[file b.py]

from typing import Final, Literal

a: Final = "a"

b: Literal["b"] = "b"

o: Final[str] = "o"

[typing fixtures/typing-typeddict.pyi]

[case testMatchMappingPatternCapturesTypedDictWithNonLiteral]

# flags: --strict-equality --warn-unreachable

from typing import TypedDict

import b

class A(TypedDict):

a: str

b: int

m: A

match m:

case {b.a: v}:

reveal_type(v) # N: Revealed type is "builtins.object"

[file b.py]

from typing import Final, Literal

a: str

[typing fixtures/typing-typeddict.pyi]

[case testMatchMappingPatternCapturesTypedDictUnreachable]

# flags: --strict-equality --warn-unreachable

# TypedDict keys are always str, so this is actually unreachable

from typing import TypedDict

import b

class A(TypedDict):

a: str

b: int

m: A

match m:

case {1: v}:

reveal_type(v) # E: Statement is unreachable

case {b.b: v2}:

reveal_type(v2) # E: Statement is unreachable

[file b.py]

b: int

[typing fixtures/typing-typeddict.pyi]

[case testMatchMappingPatternCaptureRest]

# flags: --strict-equality --warn-unreachable

m: object

match m:

case {'k': 1, **r}:

reveal_type(r) # N: Revealed type is "builtins.dict[builtins.object, builtins.object]"

[builtins fixtures/dict.pyi]

[case testMatchMappingPatternCaptureRestFromMapping]

# flags: --strict-equality --warn-unreachable

from typing import Mapping

m: Mapping[str, int]

match m:

case {'k': 1, **r}:

reveal_type(r) # N: Revealed type is "builtins.dict[builtins.str, builtins.int]"

[builtins fixtures/dict.pyi]

[case testMatchMappingPatternNarrowing]

# flags: --strict-equality --warn-unreachable

from typing import Mapping, Sequence

def f1(x: dict[str, str] | list[str] | str) -> None:

match x:

case {}:

reveal_type(x) # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"

case [*_]:

reveal_type(x) # N: Revealed type is "builtins.list[builtins.str]"

case _:

reveal_type(x) # N: Revealed type is "builtins.str"

def f1_rest(x: dict[str, str] | list[str] | str) -> None:

match x:

case {**rest}:

reveal_type(x) # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"

case [*_]:

reveal_type(x) # N: Revealed type is "builtins.list[builtins.str]"

case _:

reveal_type(x) # N: Revealed type is "builtins.str"

def f2(x: Mapping[str, str] | Sequence[str] | str) -> None:

match x:

case {}:

reveal_type(x) # N: Revealed type is "typing.Mapping[builtins.str, builtins.str]"

case [*_]:

reveal_type(x) # N: Revealed type is "typing.Sequence[builtins.str]"

case _:

# TODO: this should be str

reveal_type(x) # E: Statement is unreachable

def f2_rest(x: Mapping[str, str] | Sequence[str] | str) -> None:

match x:

case {**rest}:

reveal_type(x) # N: Revealed type is "typing.Mapping[builtins.str, builtins.str]"

case [*_]:

reveal_type(x) # N: Revealed type is "typing.Sequence[builtins.str]"

case _:

# TODO: this should be str

reveal_type(x) # E: Statement is unreachable

[builtins fixtures/primitives.pyi]

[case testMatchMappingPatternNarrowingAny]

# flags: --strict-equality --warn-unreachable

from typing import Any

def f1(x: Any) -> None:

match x:

case {}:

reveal_type(x) # N: Revealed type is "Any"

def f2(x: Any) -> None:

match x:

case {"x": "y"}:

reveal_type(x) # N: Revealed type is "Any"

[builtins fixtures/dict.pyi]

-- Class Pattern --

[case testMatchClassPatternCapturePositional]

# flags: --strict-equality --warn-unreachable

from typing import Final

class A:

__match_args__: Final = ("a", "b")

a: str

b: int

m: A

match m:

case A(i, j):

reveal_type(i) # N: Revealed type is "builtins.str"

reveal_type(j) # N: Revealed type is "builtins.int"

[builtins fixtures/tuple.pyi]

[case testMatchClassPatternMemberClassCapturePositional]

# flags: --strict-equality --warn-unreachable

import b

m: b.A

match m:

case b.A(i, j):

reveal_type(i) # N: Revealed type is "builtins.str"

reveal_type(j) # N: Revealed type is "builtins.int"

[file b.py]

from typing import Final

class A:

__match_args__: Final = ("a", "b")

a: str

b: int

[builtins fixtures/tuple.pyi]

[case testMatchClassPatternCaptureKeyword]

# flags: --strict-equality --warn-unreachable

class A:

a: str

b: int

m: A

match m:

case A(a=i, b=j):

reveal_type(i) # N: Revealed type is "builtins.str"

reveal_type(j) # N: Revealed type is "builtins.int"

[case testMatchClassPatternCaptureSelf]

# flags: --strict-equality --warn-unreachable

m: object

match m:

case bool(a):

reveal_type(a) # N: Revealed type is "builtins.bool"

case bytearray(b):

reveal_type(b) # N: Revealed type is "builtins.bytearray"

case bytes(c):

reveal_type(c) # N: Revealed type is "builtins.bytes"

case dict(d):

reveal_type(d) # N: Revealed type is "builtins.dict[Any, Any]"

case float(e):

reveal_type(e) # N: Revealed type is "builtins.float"

case frozenset(f):

reveal_type(f) # N: Revealed type is "builtins.frozenset[Any]"

case int(g):

reveal_type(g) # N: Revealed type is "builtins.int"

case list(h):

reveal_type(h) # N: Revealed type is "builtins.list[Any]"

case set(i):

reveal_type(i) # N: Revealed type is "builtins.set[Any]"

case str(j):

reveal_type(j) # N: Revealed type is "builtins.str"

case tuple(k):

reveal_type(k) # N: Revealed type is "builtins.tuple[Any, ...]"

[builtins fixtures/primitives.pyi]

[case testMatchClassPatternNarrowSelfCapture]

# flags: --strict-equality --warn-unreachable

m: object

match m:

case bool():

reveal_type(m) # N: Revealed type is "builtins.bool"

case bytearray():

reveal_type(m) # N: Revealed type is "builtins.bytearray"

case bytes():

reveal_type(m) # N: Revealed type is "builtins.bytes"

case dict():

reveal_type(m) # N: Revealed type is "builtins.dict[Any, Any]"

case float():

reveal_type(m) # N: Revealed type is "builtins.float"

case frozenset():

reveal_type(m) # N: Revealed type is "builtins.frozenset[Any]"

case int():

reveal_type(m) # N: Revealed type is "builtins.int"

case list():

reveal_type(m) # N: Revealed type is "builtins.list[Any]"

case set():

reveal_type(m) # N: Revealed type is "builtins.set[Any]"

case str():

reveal_type(m) # N: Revealed type is "builtins.str"

case tuple():

reveal_type(m) # N: Revealed type is "builtins.tuple[Any, ...]"

[builtins fixtures/primitives.pyi]

[case testMatchClassPatternCaptureSelfSubtype]

# flags: --strict-equality --warn-unreachable

class A(str):

pass

class B(str):

__match_args__ = ("b",)

b: int

def f1(x: A):

match x:

case A(a):

reveal_type(a) # N: Revealed type is "__main__.A"

def f2(x: B):

match x:

case B(b):

reveal_type(b) # N: Revealed type is "builtins.int"

[builtins fixtures/tuple.pyi]

[case testMatchInvalidClassPattern]

# flags: --strict-equality --warn-unreachable

m: object

match m:

case xyz(y): # E: Name "xyz" is not defined

reveal_type(m) # N: Revealed type is "Any"

reveal_type(y) # N: Revealed type is "Any"

match m:

case xyz(z=x): # E: Name "xyz" is not defined

reveal_type(x) # N: Revealed type is "Any"

case (xyz1() as n) | (xyz2(attr=n)): # E: Name "xyz1" is not defined \

# E: Name "xyz2" is not defined

reveal_type(n) # N: Revealed type is "Any"

[case testMatchClassPatternCaptureDataclass]

# flags: --strict-equality --warn-unreachable

from dataclasses import dataclass

@dataclass

class A:

a: str

b: int

m: A

match m:

case A(i, j):

reveal_type(i) # N: Revealed type is "builtins.str"

reveal_type(j) # N: Revealed type is "builtins.int"

[builtins fixtures/dataclasses.pyi]

[case testMatchClassPatternCaptureDataclassNoMatchArgs]

# flags: --strict-equality --warn-unreachable

from dataclasses import dataclass

@dataclass(match_args=False)

class A:

a: str

b: int

m: A

match m:

case A(i, j): # E: Class "__main__.A" doesn't define "__match_args__"

pass # E: Statement is unreachable

[builtins fixtures/dataclasses.pyi]

[case testMatchClassPatternCaptureDataclassPartialMatchArgs]

# flags: --strict-equality --warn-unreachable

from dataclasses import dataclass, field

@dataclass

class A:

a: str

b: int = field(init=False)

m: A

match m:

case A(i, j): # E: Too many positional patterns for class pattern

pass # E: Statement is unreachable

case A(k):

reveal_type(k) # N: Revealed type is "builtins.str"

[builtins fixtures/dataclasses.pyi]

[case testMatchClassPatternCaptureNamedTupleInline]

# flags: --strict-equality --warn-unreachable

from collections import namedtuple

A = namedtuple("A", ["a", "b"])

m: A

match m:

case A(i, j):

reveal_type(i) # N: Revealed type is "Any"

reveal_type(j) # N: Revealed type is "Any"

[builtins fixtures/list.pyi]

[case testMatchClassPatternCaptureNamedTupleInlineTyped]

# flags: --strict-equality --warn-unreachable

from typing import NamedTuple

A = NamedTuple("A", [("a", str), ("b", int)])

m: A

match m:

case A(i, j):

reveal_type(i) # N: Revealed type is "builtins.str"

reveal_type(j) # N: Revealed type is "builtins.int"

[builtins fixtures/list.pyi]

[case testMatchClassPatternCaptureNamedTupleClass]

# flags: --strict-equality --warn-unreachable

from typing import NamedTuple

class A(NamedTuple):

a: str

b: int

m: A

match m:

case A(i, j):

reveal_type(i) # N: Revealed type is "builtins.str"

reveal_type(j) # N: Revealed type is "builtins.int"

[builtins fixtures/tuple.pyi]

[case testMatchSequencePatternCaptureNamedTuple]

# flags: --strict-equality --warn-unreachable

from typing import NamedTuple

class N(NamedTuple):

x: int

y: str

a = N(1, "a")

match a:

case [x, y]:

reveal_type(x) # N: Revealed type is "builtins.int"

reveal_type(y) # N: Revealed type is "builtins.str"

[builtins fixtures/tuple.pyi]

[case testMatchClassPatternCaptureGeneric]

# flags: --strict-equality --warn-unreachable

from typing import Generic, TypeVar

T = TypeVar('T')

class A(Generic[T]):

a: T

m: object

match m:

case A(a=i):

reveal_type(m) # N: Revealed type is "__main__.A[Any]"

reveal_type(i) # N: Revealed type is "Any"

[case testMatchClassPatternCaptureVariadicGeneric]

# flags: --strict-equality --warn-unreachable

from typing import Generic, Tuple

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple('Ts')

class A(Generic[Unpack[Ts]]):

a: Tuple[Unpack[Ts]]

m: object

match m:

case A(a=i):

reveal_type(m) # N: Revealed type is "__main__.A[Unpack[builtins.tuple[Any, ...]]]"

reveal_type(i) # N: Revealed type is "builtins.tuple[Any, ...]"

[builtins fixtures/tuple.pyi]