@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/comparison1.py

@@ -0,0 +1,77 @@
+# This sample tests the check for non-overlapping types compared
+# with equals comparison.
+
+from typing import Literal, Optional, TypeVar, Union
+
+
+OS = Literal["Linux", "Darwin", "Windows"]
+
+
+def func1(os: OS, val: Literal[1, "linux"]):
+    if os == "Linux":
+        return True
+
+    # This should generate an error because there is no overlap in types.
+    if os == "darwin":
+        return False
+
+    # This should generate an error because there is no overlap in types.
+    if os != val:
+        return False
+
+    # This should generate an error because there is no overlap in types.
+    if val == 2:
+        return False
+
+    if val == 1:
+        return True
+
+
+class ClassA:
+    ...
+
+
+class ClassB:
+    ...
+
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2", bound=ClassB)
+
+
+def func2(
+    a: ClassA, b: ClassB, c: _T1, d: _T2, e: Union[ClassA, ClassB]
+) -> Union[None, _T1, _T2]:
+    # This should generate an error because there is no overlap in types.
+    if a == b:
+        return
+
+    # This should generate an error because there is no overlap in types.
+    if a != b:
+        return
+
+    if a != c:
+        return
+
+    # This should generate an error because there is no overlap in types.
+    if a != d:
+        return
+
+    if a == e:
+        return
+
+    if b == e:
+        return
+
+
+def func3(base: type) -> None:
+    if base == ClassA:
+        ...
+
+    if ClassA == base:
+        ...
+
+def func4(val: Optional[str]):
+    # This should generate an error because there is no overlap in types.
+    if val == 42:
+        ...

package/src/tests/samples/comparison2.py

@@ -0,0 +1,37 @@
+# This sample tests the reportUnnecessaryComparison diagnostic check
+# when applied to functions that appear within a conditional expression.
+
+
+def cond() -> bool:
+    ...
+
+
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+if cond:
+    pass
+
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+if 0 or cond:
+    pass
+
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+if 1 and cond:
+    pass
+
+if cond():
+    pass
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+elif cond:
+    pass
+
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+def func1():
+    while cond:
+        pass
+
+
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+a = [x for x in range(20) if cond]
+
+# This should generate a diagnostic when reportUnnecessaryComparison is enabled.
+a = 1 if cond else 2

package/src/tests/samples/complex1.py

@@ -0,0 +1,17 @@
+# This sample tests the type checker's handling of imaginary
+# and complex numbers.
+
+a = 3.2j
+
+b = a + 4
+
+c = 1.2 * a
+
+
+def requires_complex(val: complex):
+    ...
+
+
+requires_complex(a)
+requires_complex(b)
+requires_complex(c)

package/src/tests/samples/constant1.py

@@ -0,0 +1,40 @@
+# This sample tests the "reportConstantRedefinition" feature.
+
+ALL_CAPS_123_ = 234
+# This should generate an error if the feature is enabled.
+ALL_CAPS_123_ = 233
+
+_ = 234
+# This should not be considered a constant
+_ = 234
+
+
+a = True
+
+
+def foo():
+    LOCALVAR = 3
+
+    if a:
+        # This should generate an error if the feature is enabled.
+        LOCALVAR = 23
+
+
+from typing import TYPE_CHECKING
+
+# This should generate an error if the feature is enabled.
+TYPE_CHECKING = True
+
+
+class Foo(object):
+    CONST_VAR = 3
+
+    # This should generate an error if the feature is enabled.
+    CONST_VAR = 4
+
+    def __init__(self):
+        self.HELLO = "3"
+
+    def foo(self):
+        # This should generate an error if the feature is enabled.
+        self.HELLO = "324"

package/src/tests/samples/constants1.py

@@ -0,0 +1,64 @@
+# This sample tests that the type checker flags certain values
+# that cannot be deleted or assigned to.
+
+# This should generate an error
+True = 3
+
+# This should generate an error
+False = 4
+
+# This should generate an error
+None = True
+
+# This should generate an error
+__debug__ = 4
+
+# This should generate an error
+del True
+
+# This should generate an error
+del None
+
+# This should generate an error
+-3 = 2
+
+# This should generate an error
+[4] = [2]
+
+# This should generate an error
+[True] = [3]
+
+# This should generate an error
+(True) = 3
+
+# This should generate an error
+del -3
+
+# This should generate an error
+3 + 4 = 2
+
+# This should generate an error
+del 3 + 4
+
+# This should generate an error
+del -(4)
+
+# This should generate an error
+del __debug__
+
+# This should generate an error
+del {}
+
+# This should generate an error
+... = 3
+
+# This should generate an error
+del ...
+
+# This should generate an error
+(...) = 3
+
+# This should generate an error
+del ...
+
+

package/src/tests/samples/constructor1.py

@@ -0,0 +1,30 @@
+# This sample tests the handling of a constructor for a generic
+# class where the type arguments need to be inferred using
+# bidirectional type inference and the expected type is a
+# union of other types.
+
+from typing import Generic, TypeVar, Union, Final, Optional
+
+T = TypeVar("T")
+E = TypeVar("E")
+
+
+class Ok(Generic[T]):
+    def __init__(self, value: T) -> None:
+        self._value: Final = value
+
+
+class Err(Generic[E]):
+    def __init__(self, value: E) -> None:
+        self._value: Final = value
+
+
+Result = Union[Ok[T], Err[E]]
+
+
+def return_ok_none() -> Result[Optional[int], Exception]:
+    return Ok(None)
+
+
+def return_ok_one() -> Result[Optional[int], Exception]:
+    return Ok(1)

package/src/tests/samples/constructor10.py

@@ -0,0 +1,19 @@
+# This sample tests the handling of a __new__ method that
+# is part of a generic class but uses its own type parameters.
+
+
+from typing import Iterable, Iterator, TypeVar
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+_T = TypeVar("_T")
+
+
+class pairwise(Iterator[_T_co]):
+    def __new__(cls, __iterable: Iterable[_T]) -> "pairwise[tuple[_T, _T]]":
+        ...
+
+
+def triplewise(iterable: Iterable[_T]) -> Iterator[tuple[_T, _T, _T]]:
+    for (a, _), (b, c) in pairwise(pairwise(iterable)):
+        yield a, b, c

package/src/tests/samples/constructor11.py

@@ -0,0 +1,32 @@
+# This sample tests the case where a subclass of Dict uses
+# a dictionary literal as an argument to the constructor call.
+
+from collections import Counter, defaultdict
+from typing import Callable, Generic, Mapping, Optional, TypeVar
+
+c1 = Counter({0, 1})
+reveal_type(c1, expected_text="Counter[int]")
+
+for i in range(256):
+    c1 = Counter({0: c1[1]})
+    reveal_type(c1, expected_text="Counter[int]")
+
+reveal_type(c1, expected_text="Counter[int]")
+
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+MyFuncType = Callable[[Callable[[K], V]], V]
+
+
+class MyFunc(Generic[K, V]):
+    def __init__(self, g: MyFuncType[K, V]) -> None:
+        self.g = g
+
+
+MyFuncMapping = Mapping[K, Optional[MyFunc[K, V]]]
+
+my_func_defaultdict: MyFuncMapping[str, int] = defaultdict(
+    lambda: None, {"x": MyFunc(lambda f: f("a"))}
+)

package/src/tests/samples/constructor12.py

@@ -0,0 +1,20 @@
+# This sample tests the case where a specialized class is constructed
+# from within the class implementation and uses a class TypeVar in
+# the specialization.
+
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class Foo(Generic[T]):
+    def return_from_variable(self) -> "Foo[T]":
+        value = Foo[T]()
+        reveal_type(value, expected_text="Foo[T@Foo]")
+        return value
+
+
+x = Foo[int]()
+returned_from_variable = x.return_from_variable()
+
+reveal_type(returned_from_variable, expected_text="Foo[int]")

package/src/tests/samples/constructor13.py

@@ -0,0 +1,15 @@
+# This sample tests the case where a generic type Type[T] is
+# instantiated.
+
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class Foo(Generic[T]):
+    def __init__(self) -> None:
+        message_t = self.message_type()
+        reveal_type(message_t(), expected_text="T@Foo")
+
+    def message_type(self) -> type[T]:
+        ...

package/src/tests/samples/constructor2.py

@@ -0,0 +1,180 @@
+# This sample tests bidirectional type inference when the RHS
+# is a call to a constructor.
+
+from typing import (
+    Any,
+    Dict,
+    Generic,
+    Iterable,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+)
+
+
+_T1 = TypeVar("_T1")
+_T1_contra = TypeVar("_T1_contra", contravariant=True)
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+
+
+class Animal(Generic[_T1, _T2]):
+    pass
+
+
+class Bear(Animal[_T3, int]):
+    def __init__(self, p1: Optional[_T3] = None):
+        pass
+
+
+class Donkey(Animal[int, int], Generic[_T3]):
+    pass
+
+
+class Flyer(Protocol[_T1_contra]):
+    def get_wingspan(self, p1: _T1_contra) -> float:
+        raise NotImplemented
+
+
+class CaveDweller(Generic[_T1]):
+    pass
+
+
+class Bat(Animal[int, int], CaveDweller[int]):
+    def get_wingspan(self, p1: int) -> float:
+        raise NotImplemented
+
+
+def s1():
+    b: Bear[str] = Bear()
+    a: Animal[str, int] = b
+    reveal_type(a, expected_text="Bear[str]")
+
+
+def s2():
+    a: Animal[str, int] = Bear()
+    reveal_type(a, expected_text="Bear[str]")
+
+
+def s3():
+    a: Animal[str, int] = Bear()
+    reveal_type(a, expected_text="Bear[str]")
+
+
+def s4():
+    a: Bear[Any] = Bear[int]()
+    reveal_type(a, expected_text="Bear[Any]")
+
+
+def s5():
+    a: Animal[Any, Any] = Bear[int]()
+    reveal_type(a, expected_text="Bear[Any]")
+
+
+def s6():
+    a: Union[Bat, Bear[str]] = Bear()
+    reveal_type(a, expected_text="Bear[str]")
+
+
+def s7(p: Union[Bat, Bear[int]]):
+    a: Animal[int, int] = p
+    reveal_type(a, expected_text="Bat | Bear[int]")
+
+
+def s8():
+    a: Animal[int, int] = Bear[int]()
+    reveal_type(a, expected_text="Bear[int]")
+
+
+def s9(p: Dict[str, str]):
+    a: Dict[str, Any] = p
+    reveal_type(a, expected_text="Dict[str, Any]")
+
+
+def s10(p: List[str]):
+    a: Iterable[Any] = p
+    reveal_type(a, expected_text="List[Any]")
+    b: Iterable[str] = []
+    reveal_type(b, expected_text="list[str]")
+    c: Iterable[str] = list()
+    reveal_type(c, expected_text="list[str]")
+
+
+def s11():
+    a: Animal[Any, Any] = Donkey[int]()
+    reveal_type(a, expected_text="Donkey[int]")
+
+
+def s12(p: Bear[_T1], b: _T1):
+    a: Animal[Any, int] = p
+    reveal_type(a, expected_text="Bear[Any]")
+
+
+def s13(p: Bat):
+    a: Flyer[int] = p
+    reveal_type(a, expected_text="Bat")
+
+
+def s14(p: Bat):
+    a: CaveDweller[int] = p
+    reveal_type(a, expected_text="Bat")
+
+
+def s15():
+    a = Bear(1)
+    reveal_type(a, expected_text="Bear[int]")
+    b = Bear[int](1)
+    reveal_type(b, expected_text="Bear[int]")
+    c = Bear[float](1)
+    reveal_type(c, expected_text="Bear[float]")
+    d = Bear[Union[str, int]](1)
+    reveal_type(d, expected_text="Bear[str | int]")
+
+
+def s16():
+    a: Any = Bear(1)
+    reveal_type(a, expected_text="Any")
+
+
+def s17():
+    a1: Iterable[object] = [2, 3, 4]
+    reveal_type(a1, expected_text="list[int]")
+
+    a2: List[object] = [2, 3, 4]
+    reveal_type(a2, expected_text="list[object]")
+
+    b1: Iterable[float] = [2, 3, 4]
+    reveal_type(b1, expected_text="list[int]")
+
+    b2: List[float] = [2, 3, 4]
+    reveal_type(b2, expected_text="list[float]")
+
+    c1: Iterable[Literal["A", "B", "C"]] = ["A", "B"]
+    reveal_type(c1, expected_text="list[Literal['A', 'B']]")
+
+    c2: List[Literal["A", "B", "C"]] = ["A", "B"]
+    reveal_type(c2, expected_text="list[Literal['A', 'B', 'C']]")
+
+
+def s18():
+    a1: Mapping[object, object] = {"a": 3, "b": 5.6}
+    reveal_type(a1, expected_text="dict[object, float]")
+
+    a2: Dict[object, object] = {"a": 3, "b": 5.6}
+    reveal_type(a2, expected_text="dict[object, object]")
+
+    b1: Mapping[str, float] = {"a": 3, "b": 5}
+    reveal_type(b1, expected_text="dict[str, int]")
+
+    b2: Dict[str, float] = {"a": 3, "b": 5}
+    reveal_type(b2, expected_text="dict[str, float]")
+
+    c1: Mapping[Literal["A", "B"], Literal[3, 4]] = {"A": 3}
+    reveal_type(c1, expected_text="dict[Literal['A', 'B'], Literal[3]]")
+
+    c2: Dict[Literal["A", "B"], Literal[3, 4]] = {"A": 3}
+    reveal_type(c2, expected_text="dict[Literal['A', 'B'], Literal[3, 4]]")

package/src/tests/samples/constructor3.py

@@ -0,0 +1,18 @@
+# This sample tests inference of constructed types (in this case,
+# for "chain") when the expected type is provided by another
+# constructor (in this case "list").
+
+# pyright: strict
+
+from concurrent.futures import Future, wait
+from itertools import chain
+from typing import Any, Dict
+
+my_list = list(chain([0]))
+reveal_type(my_list, expected_text="list[int]")
+
+
+pending: Dict[Future[Any], Any] = {}
+done_tasks = wait(list(pending.keys())).done
+
+reveal_type(done_tasks, expected_text="set[Future[Any]]")

package/src/tests/samples/constructor4.py

@@ -0,0 +1,25 @@
+# This sample tests that unspecified type parameters
+# for a class instance are "unknown".
+
+from collections import defaultdict
+from queue import Queue
+from typing import DefaultDict, List, Type, TypeVar
+
+val1 = Queue()
+reveal_type(val1, expected_text="Queue[Unknown]")
+
+val2 = list()
+reveal_type(val2, expected_text="list[Unknown]")
+
+_T = TypeVar("_T")
+
+
+def foo(value: Type[_T], b: _T) -> None:
+    val1: "DefaultDict[str, list[_T]]" = defaultdict(list)
+    reveal_type(val1, expected_text="defaultdict[str, list[_T@foo]]")
+
+    val2: "DefaultDict[str, list[_T]]" = defaultdict(List[_T])
+    reveal_type(val2, expected_text="defaultdict[str, list[_T@foo]]")
+
+    # This should generate an error because the type is incompatible.
+    val3: "DefaultDict[str, list[_T]]" = defaultdict(list[int])

package/src/tests/samples/constructor5.py

@@ -0,0 +1,25 @@
+# This sample tests the case where a constructor
+# (in this case, OrderedDict) accepts a dict expression
+# that is matched against a protocol in the OrderedDict
+# constructor.
+
+from typing import OrderedDict
+
+
+val1 = {
+    "a": 1,
+    "b": 0,
+}
+reveal_type(val1, expected_text="dict[str, int]")
+
+val2 = OrderedDict(val1)
+reveal_type(val2, expected_text="OrderedDict[str, int]")
+
+
+val3 = OrderedDict(
+    {
+        "a": 1,
+        "b": 0,
+    }
+)
+reveal_type(val3, expected_text="OrderedDict[str, int]")

package/src/tests/samples/constructor6.py

@@ -0,0 +1,70 @@
+# This sample tests the special-case handling of an overloaded __init__
+# method where the "self" parameter is specialized to influence the
+# type of the constructed object.
+
+from typing import Any, Generic, Literal, Optional, Type, TypeVar, overload
+
+_T = TypeVar("_T", bound=Optional[str])
+
+
+class TextField(Generic[_T]):
+    @overload
+    def __init__(self: "TextField[str]", *, null: Literal[False] = ...) -> None:
+        ...
+
+    @overload
+    def __init__(
+        self: "TextField[Optional[str]]",
+        *,
+        null: Literal[True] = ...,
+    ) -> None:
+        ...
+
+    @overload
+    def __init__(self, *, null: bool = ...) -> None:
+        ...
+
+    def __init__(self, *, null: bool = ...) -> None:
+        ...
+
+    def __get__(self: "TextField[_T]", instance: Any, owner: Any) -> _T:
+        ...
+
+
+def foo(a: bool):
+    reveal_type(TextField(), expected_text="TextField[str]")
+    reveal_type(TextField(null=True), expected_text="TextField[str | None]")
+    reveal_type(TextField(null=a), expected_text="TextField[Unknown]")
+
+
+class Model:
+    ...
+
+
+_T1 = TypeVar("_T1", bound="Optional[Model]")
+_T2 = TypeVar("_T2", bound="Optional[Model]")
+
+
+class ForeignKey(Generic[_T1]):
+    @overload
+    def __init__(
+        self: "ForeignKey[_T2]", to: Type[_T2], *, null: Literal[False] = ...
+    ) -> None:
+        ...
+
+    @overload
+    def __init__(
+        self: "ForeignKey[Optional[_T2]]", to: Type[_T2], *, null: Literal[True]
+    ) -> None:
+        ...
+
+    def __init__(self, to: Type[_T2], *, null: bool = False) -> None:
+        ...
+
+
+class Author(Model):
+    pass
+
+
+reveal_type(ForeignKey(Author, null=False), expected_text="ForeignKey[Author]")
+reveal_type(ForeignKey(Author, null=True), expected_text="ForeignKey[Author | None]")

package/src/tests/samples/constructor7.py

@@ -0,0 +1,11 @@
+# This sample tests the case where a __new__ method provides
+# a type that differs from the class that contains it.
+
+
+class HelloWorld:
+    def __new__(cls) -> str:
+        return "Hello World"
+
+
+v1 = HelloWorld()
+reveal_type(v1, expected_text="str")