@zzzen/pyright-internal 1.1.255 → 1.2.0-beta

package/src/tests/samples/typeNarrowingIsNone2.py

@@ -1,8 +0,0 @@
-# This sample tests type narrowing for conditional
-# statements of the form X is None or X is not None
-# where X is an assignment expression.
-
-# pyright: strict
-
-i = {"a": "", "b": None}
-dict_comp = {key: w.strip() if (w := i[key]) is not None else "" for key in i}

package/src/tests/samples/typeNarrowingIsNoneTuple1.py

@@ -1,42 +0,0 @@
-# This sample tests the type narrowing case for unions of tuples
-# where one or more of the entries is tested against type None.
-
-from typing import TypeVar, Tuple, Union
-
-_T1 = TypeVar("_T1")
-
-
-def func1(a: Union[Tuple[_T1, None], Tuple[None, str]]) -> Tuple[_T1, None]:
-    if a[1] is None:
-        reveal_type(a, expected_text="Tuple[_T1@func1, None]")
-        return a
-    else:
-        reveal_type(a, expected_text="Tuple[None, str]")
-        raise ValueError()
-
-
-_T2 = TypeVar("_T2", bound=Union[None, int])
-
-
-def func2(a: Union[Tuple[_T2, None], Tuple[None, str]]):
-    if a[0] is None:
-        reveal_type(a, expected_text="Tuple[_T2@func2, None] | Tuple[None, str]")
-    else:
-        reveal_type(a, expected_text="Tuple[_T2@func2, None]")
-
-
-_T3 = TypeVar("_T3", None, int)
-
-
-def func3(a: Union[Tuple[_T3, None], Tuple[None, str]]):
-    if a[0] is None:
-        reveal_type(a, expected_text="Tuple[_T3@func3, None] | Tuple[None, str]")
-    else:
-        reveal_type(a, expected_text="Tuple[_T3@func3, None]")
-
-
-def func4(a: Union[Tuple[Union[int, None]], Tuple[None, str]]):
-    if a[0] is None:
-        reveal_type(a, expected_text="Tuple[int | None] | Tuple[None, str]")
-    else:
-        reveal_type(a, expected_text="Tuple[int | None]")

package/src/tests/samples/typeNarrowingIsNoneTuple2.py

@@ -1,35 +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 index.
-
-from typing import NamedTuple, Union
-
-IntFirst = NamedTuple("IntFirst", [
-    ("first", int),
-    ("second", None),
-])
-
-StrSecond = NamedTuple("StrSecond", [
-    ("first", None),
-    ("second", str),
-])
-
-def func1(a: Union[IntFirst, StrSecond]) -> IntFirst:
-    if a[1] 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[0] is None:
-        reveal_type(a, expected_text="UnionFirst | StrSecond")
-    else:
-        reveal_type(a, expected_text="UnionFirst")
-

package/src/tests/samples/typeNarrowingIsinstance1.py

@@ -1,162 +0,0 @@
-# This sample exercises the type analyzer's isinstance type narrowing logic.
-
-from typing import List, Optional, Sized, Type, TypeVar, Union, Any
-
-
-class UnrelatedClass:
-    class_var1: int
-
-    def __init__(self) -> None:
-        self.property: None = None
-
-
-class UnrelatedSubclass(UnrelatedClass):
-    def __init__(self) -> None:
-        self.property2: None = None
-
-
-class SuperClass:
-    class_var1: int
-
-    def __init__(self) -> None:
-        self.property: None = None
-
-
-class MyClass1(SuperClass):
-    class_var2: int
-
-    def __init__(self) -> None:
-        self.property2: None = None
-
-
-class MyClass2(SuperClass):
-    def __init__(self) -> None:
-        self.property2: None = None
-
-
-def f(instance: Union[SuperClass, UnrelatedClass]) -> None:
-    if isinstance(instance, (MyClass1, UnrelatedSubclass, Any)):
-        print(instance.property)
-
-        # This should generate two errors:
-        # 'property2' is not a known member of 'SuperClass'
-        # 'property2' is not a known member of 'UnrelatedClass'
-        print(instance.property2)
-    else:
-        print(instance.property)
-
-        # This should generate two errors:
-        # 'property2' is not a known member of 'SuperClass'
-        # 'property2' is not a known member of 'UnrelatedClass'
-        print(instance.property2)
-
-
-def g(cls: Union[Type[SuperClass], Type[UnrelatedClass]]) -> None:
-    if issubclass(cls, (MyClass1, UnrelatedSubclass, Any)):
-        print(cls.class_var1)
-
-        # This should generate two errors:
-        # 'property2' is not a known member of 'SuperClass'
-        # 'property2' is not a known member of 'UnrelatedClass'
-        print(cls.class_var2)
-    else:
-        print(cls.class_var1)
-
-        # This should generate two errors:
-        # 'property2' is not a known member of 'SuperClass'
-        # 'property2' is not a known member of 'UnrelatedClass'
-        print(cls.class_var2)
-
-
-# This code should analyze without any errors.
-class TestClass1:
-    def __init__(self) -> None:
-        self.property = True
-
-
-class TestClass2(TestClass1):
-    pass
-
-
-def func1(instance: TestClass2) -> None:
-    # Although it's redundant for code to check for either
-    # TestClass1 or TestClass2, the analyzer should be fine with it.
-    if isinstance(instance, TestClass2):
-        print(instance.property)
-
-    if isinstance(instance, TestClass1):
-        print(instance.property)
-
-
-def func2(val: Union[int, None, str]) -> Optional[int]:
-    return None if isinstance((z := val), str) else z
-
-
-# Test the special-case handling of isinstance with a
-# "type" class.
-def func3(ty: Type[int]) -> Type[int]:
-    assert isinstance(ty, (type, str))
-    return ty
-
-
-def func4(ty: Type[int]) -> Type[int]:
-    assert not isinstance(ty, str)
-    return ty
-
-
-T = TypeVar("T")
-
-
-def func5(ty: Type[T]) -> Type[T]:
-    assert isinstance(ty, (type, str))
-    return ty
-
-
-def func6(ty: Type[T]) -> Type[T]:
-    assert not isinstance(ty, str)
-    return ty
-
-
-# Test the handling of protocol classes that support runtime checking.
-def func7(a: Union[List[int], int]):
-    if isinstance(a, Sized):
-        reveal_type(a, expected_text="List[int]")
-    else:
-        reveal_type(a, expected_text="int")
-
-
-# Test handling of member access expressions whose types change based
-# on isinstance checks.
-
-
-class Base1:
-    ...
-
-
-class Sub1(Base1):
-
-    value: str
-
-
-class Sub2(Base1):
-
-    value: Base1
-
-
-def handler(node: Base1) -> Any:
-    if isinstance(node, Sub1):
-        reveal_type(node.value, expected_text="str")
-    elif isinstance(node, Sub2):
-        reveal_type(node.value, expected_text="Base1")
-        if isinstance(node.value, Sub1):
-            reveal_type(node.value, expected_text="Sub1")
-
-
-def func8(a: int | list[int] | dict[str, int] | None):
-    if isinstance(
-        a,
-        (str, (int, list, type(None))),
-    ):
-        reveal_type(a, expected_text="int | list[int] | None")
-    else:
-        reveal_type(a, expected_text="dict[str, int]")

package/src/tests/samples/typeNarrowingIsinstance2.py

@@ -1,14 +0,0 @@
-# This sample verifies that type narrowing for isinstance works
-# on "self" and other bound TypeVars.
-
-
-class Base:
-    def get_value(self) -> int:
-        if isinstance(self, Derived):
-            return self.calculate()
-        return 7
-
-
-class Derived(Base):
-    def calculate(self) -> int:
-        return 2 * 2

package/src/tests/samples/typeNarrowingIsinstance3.py

@@ -1,78 +0,0 @@
-# This sample tests the handling of isinstance and issubclass type
-# narrowing in the case where there is no overlap between the
-# value type and the test type.
-
-from typing import Type, TypeVar
-
-
-class A:
-    a_val: int
-
-
-class B:
-    b_val: int
-
-
-class C:
-    c_val: int
-
-
-def func1(val: A):
-    if isinstance(val, B):
-        val.a_val
-        val.b_val
-
-        # This should generate an error
-        val.c_val
-
-        reveal_type(val, expected_text="<subclass of A and B>")
-
-        if isinstance(val, C):
-            val.a_val
-            val.b_val
-            val.c_val
-            reveal_type(val, expected_text="<subclass of <subclass of A and B> and C>")
-
-    else:
-        val.a_val
-
-        # This should generate an error
-        val.b_val
-
-        reveal_type(val, expected_text="A")
-
-
-def func2(val: Type[A]):
-    if issubclass(val, B):
-        val.a_val
-        val.b_val
-
-        # This should generate an error
-        val.c_val
-
-        reveal_type(val, expected_text="Type[<subclass of A and B>]")
-
-        if issubclass(val, C):
-            val.a_val
-            val.b_val
-            val.c_val
-            reveal_type(
-                val, expected_text="Type[<subclass of <subclass of A and B> and C>]"
-            )
-
-    else:
-        val.a_val
-
-        # This should generate an error
-        val.b_val
-
-        reveal_type(val, expected_text="Type[A]")
-
-
-_T1 = TypeVar("_T1", bound=A)
-
-
-def func3(val: _T1) -> _T1:
-    if isinstance(val, B):
-        return val
-    return val

package/src/tests/samples/typeNarrowingIsinstance4.py

@@ -1,50 +0,0 @@
-# This sample checks the handling of callable types that are narrowed
-# to a particular type using an isinstance type narrowing test.
-
-from typing import Callable, Protocol, Union, runtime_checkable
-
-
-class Foo:
-    def __call__(self, arg: int, bar: str) -> None:
-        raise NotImplementedError
-
-
-@runtime_checkable
-class Bar(Protocol):
-    def __call__(self, arg: int) -> None:
-        raise NotImplementedError
-
-
-@runtime_checkable
-class Baz(Protocol):
-    def __call__(self, arg: str) -> None:
-        raise NotImplementedError
-
-
-def check_callable1(val: Union[Callable[[int, str], None], Callable[[int], None]]):
-    if isinstance(val, Foo):
-        reveal_type(val, expected_text="Foo")
-    else:
-        # This doesn't get narrowed because `Foo` is not a runtime checkable protocol.
-        reveal_type(val, expected_text="((int, str) -> None) | ((int) -> None)")
-
-
-def check_callable2(val: Union[Callable[[int, str], None], Callable[[int], None]]):
-    if isinstance(val, Bar):
-        reveal_type(val, expected_text="Bar")
-    else:
-        reveal_type(val, expected_text="(int, str) -> None")
-
-
-def check_callable3(val: Union[Callable[[int, str], None], Callable[[int], None]]):
-    if isinstance(val, Baz):
-        reveal_type(val, expected_text="Never")
-    else:
-        reveal_type(val, expected_text="((int, str) -> None) | ((int) -> None)")
-
-
-def check_callable4(val: Union[type, Callable[[int], None]]):
-    if isinstance(val, type):
-        reveal_type(val, expected_text="type")
-    else:
-        reveal_type(val, expected_text="(int) -> None")

package/src/tests/samples/typeNarrowingIsinstance5.py

@@ -1,39 +0,0 @@
-# This sample tests isinstance type narrowing when the class list
-# includes "Callable".
-
-from typing import Callable, List, Sequence, TypeVar, Union
-
-
-class A:
-    ...
-
-
-class B:
-    def __call__(self, x: str) -> int:
-        ...
-
-
-class C:
-    ...
-
-
-class D(C):
-    ...
-
-
-TCall1 = TypeVar("TCall1", bound=Callable[..., int])
-
-
-def func1(obj: Union[Callable[[int, str], int], List[int], A, B, C, D, TCall1]):
-    if isinstance(obj, (Callable, Sequence, C)):
-        reveal_type(
-            obj,
-            expected_text="((int, str) -> int) | List[int] | B | C | D | TCall1@func1",
-        )
-    else:
-        reveal_type(obj, expected_text="A")
-
-    if isinstance(obj, Callable):
-        reveal_type(obj, expected_text="((int, str) -> int) | B | TCall1@func1")
-    else:
-        reveal_type(obj, expected_text="List[int] | C | D | A")

package/src/tests/samples/typeNarrowingIsinstance6.py

@@ -1,77 +0,0 @@
-# This sample tests the case where isinstance or issubclass is used to
-# narrow the type of a specialized class to a subclass where the type
-# arguments are implied by the type arguments of the wider class.
-
-from typing import Any, Generic, Iterable, Sequence, Type, TypeVar, Union
-
-_T1 = TypeVar("_T1")
-
-
-class SomeClass(Generic[_T1]):
-    ...
-
-
-class OtherClass(SomeClass[_T1]):
-    ...
-
-
-def func1(a: SomeClass[int], b: Union[SomeClass[str], SomeClass[complex]]) -> None:
-    if isinstance(a, OtherClass):
-        reveal_type(a, expected_text="OtherClass[int]")
-
-    if isinstance(b, OtherClass):
-        reveal_type(b, expected_text="OtherClass[str] | OtherClass[complex]")
-
-
-def func2(
-    a: Type[SomeClass[int]], b: Union[Type[SomeClass[str]], Type[SomeClass[complex]]]
-) -> None:
-    if issubclass(a, OtherClass):
-        reveal_type(a, expected_text="Type[OtherClass[int]]")
-
-    if issubclass(b, OtherClass):
-        reveal_type(
-            b, expected_text="Type[OtherClass[str]] | Type[OtherClass[complex]]"
-        )
-
-
-def func3(value: Iterable[_T1]) -> Sequence[_T1] | None:
-    if isinstance(value, Sequence):
-        return value
-
-
-_T2 = TypeVar("_T2", bound=float, covariant=True)
-
-
-class Parent1(Generic[_T2]):
-    pass
-
-
-class Child1(Parent1[_T2]):
-    pass
-
-
-def func4(var: Parent1[int]):
-    if isinstance(var, Child1):
-        reveal_type(var, expected_text="Child1[int]")
-
-
-def func5(var: Parent1[Any]):
-    if isinstance(var, Child1):
-        reveal_type(var, expected_text="Child1[Any]")
-
-
-_T3 = TypeVar("_T3", float, str)
-
-
-class Parent2(Generic[_T3]):
-    pass
-
-
-class Child2(Parent2[_T3]):
-    pass
-
-
-def func6(var: Parent2[int]):
-    if isinstance(var, Child2):
-        reveal_type(var, expected_text="Child2[float]")

package/src/tests/samples/typeNarrowingIsinstance7.py

@@ -1,19 +0,0 @@
-# This sample tests the case where an isinstance call uses
-# a union of class types, some of which are tuples of other types
-# and some of which are not.
-
-from typing import Tuple, Type, TypeVar, Iterator, Union
-
-T1 = TypeVar("T1", bound="X")
-T2 = TypeVar("T2", bound="X")
-
-
-class X:
-    element_list: list["X"]
-
-    def return_iter(
-        self, cls: Union[Type[T1], Tuple[Type[T1], Type[T2]]]
-    ) -> Union[Iterator[T1], Iterator[T2]]:
-        for item in self.element_list:
-            if isinstance(item, cls):
-                yield item

package/src/tests/samples/typeNarrowingIsinstance8.py

@@ -1,19 +0,0 @@
-# This sample tests the case where an issubclass type guard narrows
-# to an abstract base class. When attempting to instantiate the
-# class, there should be no "cannot instantiate ABC" error.
-
-# pyright: strict
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class Base(ABC):
-    @abstractmethod
-    def f(self) -> None:
-        ...
-
-
-def func(cls: Any):
-    assert issubclass(cls, Base)
-    _ = cls()

package/src/tests/samples/typeNarrowingLiteral1.py

@@ -1,35 +0,0 @@
-# This sample tests the type analyzer's type narrowing
-# logic for literals.
-
-from typing import Literal, Union
-
-
-def func_1(p1: Literal["a", "b", "c"]):
-    if p1 != "b":
-        if p1 == "c":
-            reveal_type(p1, expected_text="Literal['c']")
-            pass
-        else:
-            reveal_type(p1, expected_text="Literal['a']")
-
-    if p1 != "a":
-        reveal_type(p1, expected_text="Literal['c', 'b']")
-    else:
-        reveal_type(p1, expected_text="Literal['a']")
-
-    if "a" != p1:
-        reveal_type(p1, expected_text="Literal['c', 'b']")
-    else:
-        reveal_type(p1, expected_text="Literal['a']")
-
-
-def func2(p1: Literal[1, 4, 7]):
-    if 4 == p1 or 1 == p1:
-        reveal_type(p1, expected_text="Literal[4, 1]")
-    else:
-        reveal_type(p1, expected_text="Literal[7]")
-
-
-def func3(a: Union[int, None]):
-    if a == 1 or a == 2:
-        reveal_type(a, expected_text="Literal[1, 2]")

package/src/tests/samples/typeNarrowingLiteral2.py

@@ -1,63 +0,0 @@
-# This sample tests the type narrowing capabilities involving
-# types that have enumerated literals (bool and enums).
-
-from enum import Enum
-from typing import Literal, Union
-
-
-class SomeEnum(Enum):
-    SOME_ENUM_VALUE1 = 1
-    SOME_ENUM_VALUE2 = 2
-    SOME_ENUM_VALUE3 = 3
-
-
-def func1(a: SomeEnum) -> Literal[3]:
-    if a == SomeEnum.SOME_ENUM_VALUE1 or a == SomeEnum.SOME_ENUM_VALUE2:
-        return 3
-    else:
-        return a.value
-
-
-def func2(a: SomeEnum) -> Literal[3]:
-    if a == SomeEnum.SOME_ENUM_VALUE1:
-        return 3
-    elif a == SomeEnum.SOME_ENUM_VALUE2:
-        return 3
-    else:
-        return a.value
-
-
-def must_be_true(a: Literal[True]):
-    ...
-
-
-def must_be_false(a: Literal[False]):
-    ...
-
-
-def func3(a: bool):
-    if a == True:
-        must_be_true(a)
-    else:
-        must_be_false(a)
-
-
-def func4(a: bool):
-    if not a:
-        must_be_false(a)
-    else:
-        must_be_true(a)
-
-
-class MyEnum(Enum):
-    ZERO = 0
-    ONE = 1
-
-
-def func5(x: Union[MyEnum, str]):
-    if x is MyEnum.ZERO:
-        reveal_type(x, expected_text="Literal[MyEnum.ZERO]")
-    elif x is MyEnum.ONE:
-        reveal_type(x, expected_text="Literal[MyEnum.ONE]")
-    else:
-        reveal_type(x, expected_text="str")