@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/src/tests/samples/typeNarrowingLiteralMember1.py

@@ -1,140 +0,0 @@
-# This sample tests type narrowing based on member accesses
-# to members that have literal types.
-
-from typing import ClassVar, Literal, Type, Union
-
-
-class A:
-    kind: Literal["A"]
-    kind_class: ClassVar[Literal["A"]]
-    d: Literal[1, 2, 3]
-    is_a: Literal[True]
-
-
-class B:
-    kind: Literal["B"]
-    kind_class: ClassVar[Literal["B"]]
-    d: Literal[3, 4, 5]
-    is_a: Literal[False]
-
-
-class C:
-    kind: str
-    kind_class: str
-    c: int
-    is_a: bool
-
-
-class D:
-    kind: Literal[1, 2, 3]
-
-
-def eq_obj1(c: Union[A, B]):
-    if c.kind == "A":
-        reveal_type(c, expected_text="A")
-    else:
-        reveal_type(c, expected_text="B")
-
-
-def is_obj1_1(c: Union[A, B]):
-    if c.kind is "A":
-        reveal_type(c, expected_text="A | B")
-    else:
-        reveal_type(c, expected_text="A | B")
-
-
-def is_obj1_2(c: Union[A, B]):
-    if c.is_a is False:
-        reveal_type(c, expected_text="B")
-    else:
-        reveal_type(c, expected_text="A")
-
-
-def eq_obj2(c: Union[A, B]):
-    if c.kind != "A":
-        reveal_type(c, expected_text="B")
-    else:
-        reveal_type(c, expected_text="A")
-
-
-def is_obj2(c: Union[A, B]):
-    if c.kind is not "A":
-        reveal_type(c, expected_text="A | B")
-    else:
-        reveal_type(c, expected_text="A | B")
-
-
-def eq_obj3(c: Union[A, B, C]):
-    if c.kind == "A":
-        reveal_type(c, expected_text="A | C")
-    else:
-        reveal_type(c, expected_text="B | C")
-
-
-def is_obj3(c: Union[A, B, C]):
-    if c.kind is "A":
-        reveal_type(c, expected_text="A | B | C")
-    else:
-        reveal_type(c, expected_text="A | B | C")
-
-
-def eq_obj4(c: Union[A, B]):
-    if c.d == 1:
-        reveal_type(c, expected_text="A")
-    elif c.d == 3:
-        reveal_type(c, expected_text="A | B")
-
-
-def is_obj4(c: Union[A, B]):
-    if c.d is 1:
-        reveal_type(c, expected_text="A | B")
-    elif c.d is 3:
-        reveal_type(c, expected_text="A | B")
-
-
-def eq_obj5(d: D):
-    if d.kind == 1:
-        reveal_type(d, expected_text="D")
-    elif d.kind == 2:
-        reveal_type(d, expected_text="D")
-
-
-def is_obj5(d: D):
-    if d.kind is 1:
-        reveal_type(d, expected_text="D")
-    elif d.kind is 2:
-        reveal_type(d, expected_text="D")
-
-
-def eq_class2(c: Union[Type[A], Type[B]]):
-    if c.kind_class == "A":
-        reveal_type(c, expected_text="Type[A]")
-    else:
-        reveal_type(c, expected_text="Type[B]")
-
-
-def is_class2(c: Union[Type[A], Type[B]]):
-    if c.kind_class is "A":
-        reveal_type(c, expected_text="Type[A] | Type[B]")
-    else:
-        reveal_type(c, expected_text="Type[A] | Type[B]")
-
-
-class E:
-    @property
-    def type(self) -> Literal[0]:
-        return 0
-
-
-class F:
-    @property
-    def type(self) -> Literal[1]:
-        return 1
-
-
-def test(x: E | F) -> None:
-    if x.type == 1:
-        reveal_type(x, expected_type="F")
-    else:
-        reveal_type(x, expected_type="E")
-

package/src/tests/samples/typeNarrowingLocalConst1.py

@@ -1,136 +0,0 @@
-# This sample tests the case where a local (constant) variable that
-# is assigned a narrowing expression can be used in a type guard condition.
-# These are sometimes referred to as "aliased conditional expressions".
-
-
-from typing import Optional, Union
-import random
-
-
-class A:
-    a: int
-
-
-class B:
-    b: int
-
-
-def func1(x: Union[A, B]) -> None:
-    is_a = not not isinstance(x, A)
-
-    if not is_a:
-        reveal_type(x, expected_text="B")
-    else:
-        reveal_type(x, expected_text="A")
-
-
-def func2(x: Union[A, B]) -> None:
-    is_a = isinstance(x, A)
-
-    if random.random() < 0.5:
-        x = B()
-
-    if is_a:
-        reveal_type(x, expected_text="B | A")
-    else:
-        reveal_type(x, expected_text="B | A")
-
-
-def func3(x: Optional[int]):
-    is_number = x != None
-
-    if is_number:
-        reveal_type(x, expected_text="int")
-    else:
-        reveal_type(x, expected_text="None")
-
-
-def func4() -> Optional[A]:
-    return A() if random.random() < 0.5 else None
-
-
-maybe_a1 = func4()
-is_a1 = maybe_a1
-
-if is_a1:
-    reveal_type(maybe_a1, expected_text="A")
-else:
-    reveal_type(maybe_a1, expected_text="None")
-
-maybe_a2 = func4()
-
-
-def func5():
-    global maybe_a2
-    maybe_a2 = False
-
-
-is_a2 = maybe_a2
-
-if is_a2:
-    reveal_type(maybe_a2, expected_text="A | None")
-else:
-    reveal_type(maybe_a2, expected_text="A | None")
-
-
-def func6(x: Union[A, B]) -> None:
-    is_a = isinstance(x, A)
-
-    for y in range(1):
-        if is_a:
-            reveal_type(x, expected_text="A | B")
-        else:
-            reveal_type(x, expected_text="A | B")
-
-        if random.random() < 0.5:
-            x = B()
-
-
-def get_string() -> str:
-    ...
-
-
-def get_optional_string() -> Optional[str]:
-    ...
-
-
-def func7(val: Optional[str] = None):
-    val = get_optional_string()
-
-    val_is_none = val is None
-
-    if val_is_none:
-        val = get_string()
-
-    reveal_type(val, expected_text="str")
-
-
-def func8(val: Optional[str] = None):
-    val = get_optional_string()
-
-    val_is_none = val is None
-
-    val = get_optional_string()
-
-    if val_is_none:
-        val = get_string()
-
-    reveal_type(val, expected_text="str | None")
-
-
-def func9(var: Optional[str] = None):
-    if var_not_None := not (var is None):
-        reveal_type(var, expected_text="str")
-
-    reveal_type(var, expected_text="str | None")
-
-    if var_not_None:
-        reveal_type(var, expected_text="str")
-
-    if 1 > 1 + 2:
-        var = None
-    else:
-        var = "a" + "b"
-
-    if var_not_None:
-        reveal_type(var, expected_text="Literal['ab'] | None")

package/src/tests/samples/typeNarrowingNoneMember1.py

@@ -1,102 +0,0 @@
-# This sample tests the type narrowing case for unions of NamedTuples
-# where one or more of the entries is tested against type None by attribute.
-
-from typing import NamedTuple, Optional, Union
-
-IntFirst = NamedTuple(
-    "IntFirst",
-    [
-        ("first", int),
-        ("second", None),
-    ],
-)
-
-StrSecond = NamedTuple(
-    "StrSecond",
-    [
-        ("first", None),
-        ("second", str),
-    ],
-)
-
-
-def func1(a: Union[IntFirst, StrSecond]) -> IntFirst:
-    if a.second is None:
-        reveal_type(a, expected_text="IntFirst")
-        return a
-    else:
-        reveal_type(a, expected_text="StrSecond")
-        raise ValueError()
-
-
-UnionFirst = NamedTuple(
-    "UnionFirst",
-    [
-        ("first", Union[None, int]),
-        ("second", None),
-    ],
-)
-
-
-def func2(a: Union[UnionFirst, StrSecond]):
-    if a.first is None:
-        reveal_type(a, expected_text="UnionFirst | StrSecond")
-    else:
-        reveal_type(a, expected_text="UnionFirst")
-
-
-class A:
-    @property
-    def prop1(self) -> Optional[int]:
-        ...
-
-    member1: None
-    member2: Optional[int]
-    member3: Optional[int]
-    member4: Optional[int]
-
-
-class B:
-    @property
-    def prop1(self) -> int:
-        ...
-
-    member1: int
-    member2: Optional[int]
-    member3: None
-    member4: int
-
-
-def func3(c: Union[A, B]):
-    if c.prop1 is None:
-        reveal_type(c, expected_text="A | B")
-    else:
-        reveal_type(c, expected_text="A | B")
-
-
-def func4(c: Union[A, B]):
-    if c.member1 is None:
-        reveal_type(c, expected_text="A")
-    else:
-        reveal_type(c, expected_text="B")
-
-
-def func5(c: Union[A, B]):
-    if c.member2 is None:
-        reveal_type(c, expected_text="A | B")
-    else:
-        reveal_type(c, expected_text="A | B")
-
-
-def func6(c: Union[A, B]):
-    if c.member3 is not None:
-        reveal_type(c, expected_text="A")
-    else:
-        reveal_type(c, expected_text="A | B")
-
-
-def func7(c: Union[A, B]):
-    if c.member4 is not None:
-        reveal_type(c, expected_text="A | B")
-    else:
-        reveal_type(c, expected_text="A")

package/src/tests/samples/typeNarrowingTuple1.py

@@ -1,23 +0,0 @@
-# This sample tests the type narrowing for known-length tuples
-# that have an entry with a declared literal type.
-
-from typing import Tuple, Union, Literal
-
-MsgA = Tuple[Literal[1], str]
-MsgB = Tuple[Literal[2], float]
-
-Msg = Union[MsgA, MsgB]
-
-
-def func1(m: Msg):
-    if m[0] == 1:
-        reveal_type(m, expected_text="Tuple[Literal[1], str]")
-    else:
-        reveal_type(m, expected_text="Tuple[Literal[2], float]")
-
-
-def func2(m: Msg):
-    if m[0] != 1:
-        reveal_type(m, expected_text="Tuple[Literal[2], float]")
-    else:
-        reveal_type(m, expected_text="Tuple[Literal[1], str]")

package/src/tests/samples/typeNarrowingTupleLength1.py

@@ -1,47 +0,0 @@
-# This sample tests type narrowing of tuples based on len(x) test.
-
-from typing import Tuple, TypeVar, Union
-
-
-def func1(val: Union[Tuple[int], Tuple[int, int], Tuple[str, str]]):
-    if len(val) == 1:
-        reveal_type(val, expected_text="Tuple[int]")
-    else:
-        reveal_type(val, expected_text="Tuple[int, int] | Tuple[str, str]")
-
-    if len(val) != 2:
-        reveal_type(val, expected_text="Tuple[int]")
-    else:
-        reveal_type(val, expected_text="Tuple[int, int] | Tuple[str, str]")
-
-
-def func2(val: Union[Tuple[int], Tuple[int, ...]]):
-    if len(val) == 1:
-        reveal_type(val, expected_text="Tuple[int] | Tuple[int, ...]")
-    else:
-        reveal_type(val, expected_text="Tuple[int, ...]")
-
-    if len(val) != 2:
-        reveal_type(val, expected_text="Tuple[int] | Tuple[int, ...]")
-    else:
-        reveal_type(val, expected_text="Tuple[int, ...]")
-
-
-def func3(val: Union[Tuple[int], Tuple[()]]):
-    if len(val) == 0:
-        reveal_type(val, expected_text="Tuple[()]")
-    else:
-        reveal_type(val, expected_text="Tuple[int]")
-
-
-_T1 = TypeVar("_T1", bound=Tuple[int])
-_T2 = TypeVar("_T2", bound=Tuple[str, str])
-
-
-def func4(val: Union[_T1, _T2]) -> Union[_T1, _T2]:
-    if len(val) == 1:
-        reveal_type(val, expected_text="_T1@func4")
-    else:
-        reveal_type(val, expected_text="_T2@func4")
-
-    return val

package/src/tests/samples/typeNarrowingTypeIs1.py

@@ -1,95 +0,0 @@
-# This sample exercises the type analyzer's type narrowing
-# logic for tests of the form "type(X) is Y" or "type(X) is not Y".
-
-from typing import Any, Dict, Generic, Optional, TypeVar, Union, final
-
-
-def func1(a: Union[str, int]) -> int:
-
-    if type(a) is not str:
-        # This should generate an error because
-        # "a" is potentially a subclass of str.
-        return a
-
-    # This should generate an error because
-    # "a" is provably type str at this point.
-    return a
-
-
-def func2(a: Optional[str]) -> str:
-
-    if type(a) is str:
-        return a
-
-    # This should generate an error because
-    # "a" is provably type str at this point.
-    return a
-
-
-def func3(a: Dict[str, Any]) -> str:
-    val = a.get("hello")
-    if type(val) is str:
-        return val
-
-    return "none"
-
-
-class A:
-    pass
-
-
-class B(A):
-    pass
-
-
-def func4(a: Union[str, A]):
-    if type(a) is B:
-        reveal_type(a, expected_text="B")
-    else:
-        reveal_type(a, expected_text="str | A")
-
-
-T = TypeVar("T")
-
-
-class C(Generic[T]):
-    def __init__(self, a: T):
-        self.a = a
-
-
-class D:
-    pass
-
-
-E = Union[C[T], D]
-
-
-def func5(x: E[T]) -> None:
-    if type(x) is C:
-        reveal_type(x, expected_text="C[T@func5]")
-
-
-@final
-class AFinal:
-    pass
-
-
-@final
-class BFinal:
-    pass
-
-
-def func6(val: Union[AFinal, BFinal]) -> None:
-    if type(val) is AFinal:
-        reveal_type(val, expected_text="AFinal")
-    else:
-        reveal_type(val, expected_text="BFinal")
-
-
-def func7(val: Any):
-    if type(val) is int:
-        reveal_type(val, expected_text="int")
-    else:
-        reveal_type(val, expected_text="Any")
-
-    reveal_type(val, expected_text="int | Any")

package/src/tests/samples/typeNarrowingTypedDict1.py

@@ -1,99 +0,0 @@
-# This sample tests type narrowing for TypedDict types based
-# on whether a key is in or not in the dict.
-
-from typing import TypedDict, Union, final
-
-
-@final
-class TD1(TypedDict):
-    a: str
-    b: int
-
-
-@final
-class TD2(TypedDict):
-    a: int
-    c: str
-
-
-@final
-class TD3(TypedDict, total=False):
-    a: int
-    d: str
-
-
-class TD4(TypedDict):
-    a: int
-    c: str
-
-
-def f1(p: Union[TD1, TD2]):
-    if "b" in p:
-        reveal_type(p, expected_text="TD1")
-    else:
-        reveal_type(p, expected_text="TD2")
-
-
-def f2(p: Union[TD1, TD2]):
-    if "b" not in p:
-        reveal_type(p, expected_text="TD2")
-    else:
-        reveal_type(p, expected_text="TD1")
-
-
-def f3(p: Union[TD1, TD3]):
-    if "d" in p:
-        reveal_type(p, expected_text="TD3")
-    else:
-        reveal_type(p, expected_text="TD1 | TD3")
-
-
-def f4(p: Union[TD1, TD3]):
-    if "d" not in p:
-        reveal_type(p, expected_text="TD1 | TD3")
-    else:
-        reveal_type(p, expected_text="TD3")
-
-
-def f5(p: Union[TD1, TD3]):
-    if "a" in p:
-        reveal_type(p, expected_text="TD1 | TD3")
-    else:
-        reveal_type(p, expected_text="TD3")
-
-
-def f6(p: Union[TD1, TD2, TD3]):
-    # This should generate an error for TD3.
-    v1 = p["a"]
-
-    v2 = p.get("a")
-
-    if "c" in p:
-        v3 = p["c"]
-        reveal_type(v3, expected_text="str")
-
-    if "a" in p and "d" in p:
-        v4 = p["a"]
-        reveal_type(v4, expected_text="int")
-
-        v5 = p["d"]
-        reveal_type(v5, expected_text="str")
-
-    # This should generate two errors, one for TD1 and another for TD2.
-    v6 = p["d"]
-
-
-def f7(p: TD3):
-    pass
-
-
-def f8(p: TD3):
-    if "a" in p:
-        f7(p)
-
-
-def f9(p: Union[TD1, TD4]):
-    if "b" in p:
-        reveal_type(p, expected_text="TD1 | TD4")
-    else:
-        reveal_type(p, expected_text="TD4")

package/src/tests/samples/typeNarrowingTypedDict2.py

@@ -1,35 +0,0 @@
-# This sample tests type narrowing based on key accesses
-# to unions of TypedDicts that have fields with literal types.
-
-from typing import Literal, TypedDict, Union
-
-
-class NewJobEvent(TypedDict):
-    tag: Literal["new-job"]
-    job_name: str
-    config_file_path: str
-
-
-class CancelJobEvent(TypedDict):
-    tag: Literal[2]
-    job_id: int
-
-
-class OtherEvent(TypedDict):
-    tag: Literal["other-job"]
-    message: str
-
-
-Event = Union[NewJobEvent, CancelJobEvent, OtherEvent]
-
-
-def process_event(event: Event) -> None:
-    if event["tag"] == "new-job":
-        reveal_type(event, expected_text="NewJobEvent")
-        event["job_name"]
-    elif event["tag"] == 2:
-        reveal_type(event, expected_text="CancelJobEvent")
-        event["job_id"]
-    else:
-        reveal_type(event, expected_text="OtherEvent")
-        event["message"]