@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/match3.py

@@ -0,0 +1,364 @@
+# This sample tests type checking for match statements (as
+# described in PEP 634) that contain class patterns.
+
+from typing import Any, Generic, Literal, NamedTuple, Optional, TypeVar, Union
+from dataclasses import dataclass, field
+
+foo = 3
+
+T = TypeVar("T")
+
+
+class ClassA:
+    __match_args__ = ("attr_a", "attr_b")
+    attr_a: int
+    attr_b: str
+
+
+class ClassB(Generic[T]):
+    __match_args__ = ("attr_a", "attr_b")
+    attr_a: T
+    attr_b: str
+
+
+class ClassC:
+    ...
+
+
+class ClassD(ClassC):
+    ...
+
+
+def test_unknown(value_to_match):
+    match value_to_match:
+        case ClassA(attr_a=a2) as a1:
+            reveal_type(a1, expected_text="ClassA")
+            reveal_type(a2, expected_text="int")
+            reveal_type(value_to_match, expected_text="ClassA")
+
+        # This should generate an error because foo isn't instantiable.
+        case foo() as a3:
+            pass
+
+
+def test_any(value_to_match: Any):
+    match value_to_match:
+        case list() as a1:
+            reveal_type(a1, expected_text="list[Unknown]")
+            reveal_type(value_to_match, expected_text="list[Unknown]")
+
+
+def test_custom_type(value_to_match: ClassA | ClassB[int] | ClassB[str] | ClassC):
+    match value_to_match:
+        case int() as a1:
+            reveal_type(a1, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+        case ClassA(attr_a=a4, attr_b=a5) as a3:
+            reveal_type(a3, expected_text="ClassA")
+            reveal_type(a4, expected_text="int")
+            reveal_type(a5, expected_text="str")
+            reveal_type(value_to_match, expected_text="ClassA")
+            reveal_type(value_to_match, expected_text="ClassA")
+
+        case ClassB(a6, a7):
+            reveal_type(a6, expected_text="int | str")
+            reveal_type(a7, expected_text="str")
+            reveal_type(value_to_match, expected_text="ClassB[int] | ClassB[str]")
+
+        case ClassD() as a2:
+            reveal_type(a2, expected_text="ClassD")
+            reveal_type(value_to_match, expected_text="ClassD")
+
+        case ClassC() as a8:
+            reveal_type(a8, expected_text="ClassC")
+            reveal_type(value_to_match, expected_text="ClassC")
+
+
+def test_literal(value_to_match: Literal[3]):
+    match value_to_match:
+        case int() as a1:
+            reveal_type(a1, expected_text="Literal[3]")
+            reveal_type(value_to_match, expected_text="Literal[3]")
+
+        case float() as a2:
+            reveal_type(a2, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+        case str() as a3:
+            reveal_type(a3, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+
+TFloat = TypeVar("TFloat", bound=float)
+
+
+def test_bound_typevar(value_to_match: TFloat) -> TFloat:
+    match value_to_match:
+        case int() as a1:
+            reveal_type(a1, expected_text="int*")
+            reveal_type(value_to_match, expected_text="int*")
+
+        case float() as a2:
+            reveal_type(a2, expected_text="float*")
+            reveal_type(value_to_match, expected_text="float*")
+
+        case str() as a3:
+            reveal_type(a3, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+    return value_to_match
+
+
+TInt = TypeVar("TInt", bound=int)
+
+
+def test_union(
+    value_to_match: Union[TInt, Literal[3], float, str]
+) -> Union[TInt, Literal[3], float, str]:
+    match value_to_match:
+        case int() as a1:
+            reveal_type(a1, expected_text="int* | int")
+            reveal_type(value_to_match, expected_text="int* | int")
+
+        case float() as a2:
+            reveal_type(a2, expected_text="float")
+            reveal_type(value_to_match, expected_text="float")
+
+        case str() as a3:
+            reveal_type(a3, expected_text="str")
+            reveal_type(value_to_match, expected_text="str")
+
+    return value_to_match
+
+
+T = TypeVar("T")
+
+
+class Point(Generic[T]):
+    __match_args__ = ("x", "y")
+    x: T
+    y: T
+
+
+def func1(points: list[Point[float] | Point[complex]]):
+    match points:
+        case [] as a1:
+            reveal_type(a1, expected_text="list[Point[float] | Point[complex]]")
+            reveal_type(points, expected_text="list[Point[float] | Point[complex]]")
+
+        case [Point(0, 0) as b1]:
+            reveal_type(b1, expected_text="Point[float] | Point[complex]")
+            reveal_type(points, expected_text="list[Point[float] | Point[complex]]")
+
+        case [Point(c1, c2)]:
+            reveal_type(c1, expected_text="float | complex")
+            reveal_type(c2, expected_text="float | complex")
+            reveal_type(points, expected_text="list[Point[float] | Point[complex]]")
+
+        case [Point(0, d1), Point(0, d2)]:
+            reveal_type(d1, expected_text="float | complex")
+            reveal_type(d2, expected_text="float | complex")
+            reveal_type(points, expected_text="list[Point[float] | Point[complex]]")
+
+        case _ as e1:
+            reveal_type(e1, expected_text="list[Point[float] | Point[complex]]")
+            reveal_type(points, expected_text="list[Point[float] | Point[complex]]")
+
+
+def func2(subj: object):
+    match subj:
+        case list() as a1:
+            reveal_type(a1, expected_text="list[Unknown]")
+            reveal_type(subj, expected_text="list[Unknown]")
+
+
+def func3(subj: Union[int, str, dict[str, str]]):
+    match subj:
+        case int(x):
+            reveal_type(x, expected_text="int")
+            reveal_type(subj, expected_text="int")
+
+        case str(x):
+            reveal_type(x, expected_text="str")
+            reveal_type(subj, expected_text="str")
+
+        case dict(x):
+            reveal_type(x, expected_text="dict[str, str]")
+            reveal_type(subj, expected_text="dict[str, str]")
+
+
+def func4(subj: object):
+    match subj:
+        case int(x):
+            reveal_type(x, expected_text="int")
+            reveal_type(subj, expected_text="int")
+
+        case str(x):
+            reveal_type(x, expected_text="str")
+            reveal_type(subj, expected_text="str")
+
+
+# Test the auto-generation of __match_args__ for dataclass.
+@dataclass
+class Dataclass1:
+    val1: int
+    val2: str = field(init=False)
+    val3: complex
+
+
+@dataclass
+class Dataclass2:
+    val1: int
+    val2: str
+    val3: float
+
+
+def func5(subj: object):
+    match subj:
+        case Dataclass1(a, b):
+            reveal_type(a, expected_text="int")
+            reveal_type(b, expected_text="complex")
+            reveal_type(subj, expected_text="Dataclass1")
+
+        case Dataclass2(a, b, c):
+            reveal_type(a, expected_text="int")
+            reveal_type(b, expected_text="str")
+            reveal_type(c, expected_text="float")
+            reveal_type(subj, expected_text="Dataclass2")
+
+
+# Test the auto-generation of __match_args__ for named tuples.
+NT1 = NamedTuple("NT1", [("val1", int), ("val2", complex)])
+NT2 = NamedTuple("NT2", [("val1", int), ("val2", str), ("val3", float)])
+
+
+def func6(subj: object):
+    match subj:
+        case NT1(a, b):
+            reveal_type(a, expected_text="int")
+            reveal_type(b, expected_text="complex")
+            reveal_type(subj, expected_text="NT1")
+
+        case NT2(a, b, c):
+            reveal_type(a, expected_text="int")
+            reveal_type(b, expected_text="str")
+            reveal_type(c, expected_text="float")
+            reveal_type(subj, expected_text="NT2")
+
+
+def func7(subj: object):
+    match subj:
+        case complex(real=a, imag=b):
+            reveal_type(a, expected_text="float")
+            reveal_type(b, expected_text="float")
+
+
+T2 = TypeVar("T2")
+
+
+class Parent(Generic[T]):
+    ...
+
+
+class Child1(Parent[T]):
+    ...
+
+
+class Child2(Parent[T], Generic[T, T2]):
+    ...
+
+
+def func8(subj: Parent[int]):
+    match subj:
+        case Child1() as a1:
+            reveal_type(a1, expected_text="Child1[int]")
+            reveal_type(subj, expected_text="Child1[int]")
+
+        case Child2() as b1:
+            reveal_type(b1, expected_text="Child2[int, Unknown]")
+            reveal_type(subj, expected_text="Child2[int, Unknown]")
+
+
+T3 = TypeVar("T3")
+
+
+def func9(v: T3) -> Optional[T3]:
+    match v:
+        case str():
+            reveal_type(v, expected_text="str*")
+            return v
+
+        case _:
+            return None
+
+
+T4 = TypeVar("T4", int, str)
+
+
+def func10(v: T4) -> Optional[T4]:
+    match v:
+        case str():
+            reveal_type(v, expected_text="str*")
+            return v
+
+        case int():
+            reveal_type(v, expected_text="int*")
+            return v
+
+        case list():
+            reveal_type(v, expected_text="Never")
+            return v
+
+        case _:
+            return None
+
+
+def func11(subj: Any):
+    match subj:
+        case Child1() as a1:
+            reveal_type(a1, expected_text="Child1[Unknown]")
+            reveal_type(subj, expected_text="Child1[Unknown]")
+
+        case Child2() as b1:
+            reveal_type(b1, expected_text="Child2[Unknown, Unknown]")
+            reveal_type(subj, expected_text="Child2[Unknown, Unknown]")
+
+
+def func12(subj: int, flt_cls: type[float], union_val: float | int):
+    match subj:
+        # This should generate an error because int doesn't accept two arguments.
+        case int(1, 2):
+            pass
+
+    match subj:
+        # This should generate an error because float doesn't accept keyword arguments.
+        case float(x=1):
+            pass
+
+    match subj:
+        case flt_cls():
+            pass
+
+        # This should generate an error because it is a union.
+        case union_val():
+            pass
+
+
+def func13(subj: tuple[Literal[0]]):
+    match subj:
+        case tuple((1,)) as a:
+            reveal_type(subj, expected_text="Never")
+            reveal_type(a, expected_text="Never")
+
+        case tuple((0, 0)) as b:
+            reveal_type(subj, expected_text="Never")
+            reveal_type(b, expected_text="Never")
+
+        case tuple((0,)) as c:
+            reveal_type(subj, expected_text="tuple[Literal[0]]")
+            reveal_type(c, expected_text="tuple[Literal[0]]")
+
+        case d:
+            reveal_type(subj, expected_text="Never")
+            reveal_type(d, expected_text="Never")

package/src/tests/samples/match4.py

@@ -0,0 +1,100 @@
+# This sample tests type checking for match statements (as
+# described in PEP 634) that contain value patterns.
+
+from enum import Enum, auto
+from typing import Tuple, TypeVar, Union
+from http import HTTPStatus
+
+def handle_reply(reply: Tuple[HTTPStatus, str] | Tuple[HTTPStatus]):
+    match reply:
+        case (HTTPStatus.OK as a1, a2):
+            reveal_type(a1, expected_text="Literal[HTTPStatus.OK]")
+            reveal_type(a2, expected_text="str")
+
+        case (HTTPStatus.NOT_FOUND as d1, ):
+            reveal_type(d1, expected_text="Literal[HTTPStatus.NOT_FOUND]")
+
+
+class MyEnum(Enum):
+    V1 = 0
+    V2 = 1
+
+class MyClass:
+    class_var_1: "MyClass"
+
+    def __eq__(self, object: "MyClass") -> bool: ...
+
+def test_unknown(value_to_match):
+    match value_to_match:
+        case MyEnum.V1 as a1:
+            reveal_type(a1, expected_text="Unknown")
+            reveal_type(value_to_match, expected_text="Unknown")
+
+
+def test_enum(value_to_match: MyEnum):
+    match value_to_match:
+        case MyEnum.V1 as a1:
+            reveal_type(a1, expected_text="Literal[MyEnum.V1]")
+            reveal_type(value_to_match, expected_text="Literal[MyEnum.V1]")
+
+
+def test_class_var(value_to_match: str):
+    match value_to_match:
+        case MyClass.class_var_1 as a1:
+            reveal_type(a1, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+
+TInt = TypeVar("TInt", bound=MyEnum)
+
+def test_union(value_to_match: Union[TInt, MyEnum]) -> Union[TInt, MyEnum]:
+    match value_to_match:
+        case MyEnum.V1 as a1:
+            reveal_type(a1, expected_text="Literal[MyEnum.V1]")
+            reveal_type(value_to_match, expected_text="Literal[MyEnum.V1]")
+
+    return value_to_match
+
+
+class Medal(Enum):
+    gold = 1
+    silver = 2
+    bronze = 3
+
+class Color(Enum):
+    red = 1
+    blue = 2
+    green = 3
+
+
+def test_enum_narrowing(m: Union[Medal, Color, int]):
+    match m:
+        case Medal.gold as a1:
+            reveal_type(a1, expected_text='Literal[Medal.gold]')
+            reveal_type(m, expected_text='Literal[Medal.gold]')
+
+        case Medal.silver as b1:
+            reveal_type(b1, expected_text='Literal[Medal.silver]')
+            reveal_type(m, expected_text='Literal[Medal.silver]')
+
+        case Color() as c1:
+            reveal_type(c1, expected_text='Color')
+            reveal_type(m, expected_text='Color')
+
+        case d1:
+            reveal_type(d1, expected_text='int | Literal[Medal.bronze]')
+            reveal_type(m, expected_text='int | Literal[Medal.bronze]')
+
+
+class Foo(Enum):
+    bar = auto()
+
+    def __str__(self) -> str:
+        match self:
+            case Foo.bar:
+                return "bar"
+
+            case x:
+                reveal_type(x, expected_text="Never")
+
+

package/src/tests/samples/match5.py

@@ -0,0 +1,70 @@
+# This sample tests type checking for match statements (as
+# described in PEP 634) that contain mapping patterns.
+
+from typing import Dict, Literal, TypedDict
+
+def test_unknown(value_to_match):
+    match value_to_match:
+        case {"hello": a1, **a2}:
+            reveal_type(a1, expected_text="Unknown")
+            reveal_type(a2, expected_text="dict[Unknown, Unknown]")
+            reveal_type(value_to_match, expected_text="Unknown")
+
+
+def test_dict(value_to_match: Dict[str | int, str | int]):
+    match value_to_match:
+        case {1: a1}:
+            reveal_type(a1, expected_text="str | int")
+            reveal_type(value_to_match, expected_text="Dict[str | int, str | int]")
+
+        case {"hi": b1, "hi2": b2, **b3}:
+            reveal_type(b1, expected_text="str | int")
+            reveal_type(b2, expected_text="str | int")
+            reveal_type(b3, expected_text="dict[str | int, str | int]")
+            reveal_type(value_to_match, expected_text="Dict[str | int, str | int]")
+
+        case {3j: c1}:
+            reveal_type(c1, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+
+class Movie(TypedDict):
+    title: str
+    release_year: int
+    gross_earnings: float
+
+class MovieInfo:
+    field_of_interest: Literal["release_year", "gross_earnings"]
+
+def test_typed_dict(value_to_match: Movie):
+    match value_to_match:
+        case {"title": a1, "release_year": a2, **a3}:
+            reveal_type(a1, expected_text="str")
+            reveal_type(a2, expected_text="int")
+            reveal_type(a3, expected_text="dict[str, Unknown]")
+            reveal_type(value_to_match, expected_text="Movie")
+
+        case {3: b1, "title": b2}:
+            reveal_type(b1, expected_text="Never")
+            reveal_type(b2, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+
+        case {"director": c1}:
+            reveal_type(c1, expected_text="Never")
+            reveal_type(value_to_match, expected_text="Never")
+        
+        case {MovieInfo.field_of_interest: d1}:
+            reveal_type(d1, expected_text="int | float")
+            reveal_type(value_to_match, expected_text="Movie")
+
+
+def test_union(value_to_match: Dict[str | int, str | int] | Movie | str):
+    match value_to_match:
+        case {3: a1}:
+            reveal_type(a1, expected_text="str | int")
+            reveal_type(value_to_match, expected_text="Dict[str | int, str | int]")
+
+        case {"gross_earnings": b1}:
+            reveal_type(b1, expected_text="str | int | float")
+            reveal_type(value_to_match, expected_text="Dict[str | int, str | int] | Movie")
+

package/src/tests/samples/match6.py

@@ -0,0 +1,64 @@
+# This sample tests type checking for match statements (as
+# described in PEP 634) that contain literal patterns.
+
+
+def test_unknown(value_to_match):
+    match value_to_match:
+        case 3 as a1, -3 as a2:
+            reveal_type(a1, expected_text="Literal[3]")
+            reveal_type(a2, expected_text="Literal[-3]")
+            reveal_type(value_to_match, expected_text="Unknown")
+
+        case 3j as b1, -3 + 5j as b2:
+            reveal_type(b1, expected_text="complex")
+            reveal_type(b2, expected_text="complex")
+            reveal_type(value_to_match, expected_text="Unknown")
+
+        case "hi" as c1, None as c2:
+            reveal_type(c1, expected_text="Literal['hi']")
+            reveal_type(c2, expected_text="None")
+            reveal_type(value_to_match, expected_text="Unknown")
+
+        case True as d1, False as d2:
+            reveal_type(d1, expected_text="Literal[True]")
+            reveal_type(d2, expected_text="Literal[False]")
+            reveal_type(value_to_match, expected_text="Unknown")
+
+def test_tuple(value_to_match: tuple[int | float | str | complex, ...]):
+    match value_to_match:
+        case (3, -3) as a1:
+            reveal_type(a1, expected_text="tuple[Literal[3], Literal[-3]]")
+            reveal_type(value_to_match, expected_text="tuple[Literal[3], Literal[-3]]")
+
+        case (3j , -3 + 5j) as b1:
+            reveal_type(b1, expected_text="tuple[complex, complex]")
+            reveal_type(value_to_match, expected_text="tuple[complex, complex]")
+
+
+def test_union(value_to_match: int | float | str | complex | bool | None):
+    match value_to_match:
+        case (3 | -3j) as a1:
+            reveal_type(a1, expected_text="complex | Literal[3]")
+            reveal_type(value_to_match, expected_text="complex | Literal[3]")
+
+        case (True | False | 3.4 | -3 + 3j | None) as b1:
+            reveal_type(b1, expected_text="float | complex | bool | None")
+            reveal_type(value_to_match, expected_text="float | complex | bool | None")
+
+        case ("hi" | 3.4) as c1:
+            reveal_type(c1, expected_text="float | Literal['hi']")
+            reveal_type(value_to_match, expected_text="float | Literal['hi']")
+
+        case ((True | "True") as d1) | ((False | "False") as d1):
+            reveal_type(d1, expected_text="bool | Literal['True', 'False']")
+            reveal_type(value_to_match, expected_text="bool | Literal['True', 'False']")
+
+
+def test_none(value_to_match: int | None):
+    match value_to_match:
+        case None as a1:
+            reveal_type(a1, expected_text="None")
+
+        case a2:
+            reveal_type(a2, expected_text="int")
+

package/src/tests/samples/match7.py

@@ -0,0 +1,65 @@
+# This sample tests type narrowing of subject expressions for
+# match statements.
+
+
+def func1(subj: int | dict[str, str] | tuple[int] | str, cond: bool):
+    match subj:
+        case (3 | "hi"):
+            reveal_type(subj, expected_text="Literal[3, 'hi']")
+            return
+
+        case int(y) if cond:
+            reveal_type(subj, expected_text="int")
+            return
+
+        case int(y):
+            reveal_type(subj, expected_text="int")
+            return
+
+        case int():
+            reveal_type(subj, expected_text="Never")
+            return
+
+        case str(z):
+            reveal_type(subj, expected_text="str")
+            return
+
+    reveal_type(subj, expected_text="dict[str, str] | tuple[int]")
+    return subj
+
+
+# This should generate an error because there is the potential
+# for fall-through if the subject expression is a str.
+def func2(subj: int | str) -> str:
+    match subj:
+        case int():
+            return "int"
+    
+    reveal_type(subj, expected_text='str')
+
+
+# This should generate an error because there is the potential
+# for fall-through if the guard expressions are false.
+def func3(subj: int | str) -> str:
+    match subj:
+        case str() if len(subj) > 0:
+            return "str"
+
+        case int() if subj < 0:
+            return "int"
+    
+    reveal_type(subj, expected_text='int | str')
+
+
+def func4(subj: int | str) -> str:
+    match subj:
+        case int():
+            return "int"
+
+        case str():
+            return "str"
+        
+        case _:
+            # This should be ignored because the pattern has already
+            # been exhaustively matched.
+            pass

package/src/tests/samples/match8.py

@@ -0,0 +1,19 @@
+# This sample tests keyword-only class pattern matching for
+# dataclasses.
+
+from dataclasses import dataclass, field
+
+@dataclass
+class Point:
+    optional: int | None = field(default=None, kw_only=True)
+    x: int
+    y: int
+
+
+obj = Point(1, 2)
+match obj:
+    case Point(x, y, optional=opt):
+        reveal_type(x, expected_text="int")
+        reveal_type(y, expected_text="int")
+        reveal_type(opt, expected_text="int | None")
+        distance = (x ** 2 + y ** 2) ** 0.5