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

package/src/tests/samples/unnecessaryIsInstance1.py

@@ -1,91 +0,0 @@
-# This sample tests unnecessary isinstance error reporting.
-
-from typing import (
-    ClassVar,
-    Protocol,
-    Type,
-    TypedDict,
-    Union,
-    runtime_checkable,
-)
-
-from unknown_import import CustomClass1
-
-
-class CustomClass2(CustomClass1):
-    pass
-
-
-def func1(p1: int, p2: Union[int, str]):
-    a = isinstance(p2, str)
-
-    b = isinstance(p2, (int, float))
-
-    # This should generate an error because this is always true.
-    c = isinstance(p2, (float, dict, int, str))
-
-    d = isinstance(p1, float)
-
-    e = isinstance(p2, (float, dict, int))
-
-    # This should generate an error because this is always true.
-    f = isinstance(p1, int)
-
-    # This should not generate an error because it's within an assert.
-    assert isinstance(p1, int)
-
-    g = CustomClass2()
-    # This should not generate an error because CustomClass2
-    # derives from an unknown type.
-    g = isinstance(g, CustomClass1)
-
-
-class SomeTypedDict(TypedDict):
-    name: str
-
-
-def func2(p1: SomeTypedDict, p2: Union[int, SomeTypedDict]):
-    a = isinstance(p2, dict)
-
-    # This should generate an error because it's always true.
-    b = isinstance(p1, dict)
-
-
-@runtime_checkable
-class BaseClass(Protocol):
-    text: ClassVar[str] = "FOO"
-
-
-class ClassA:
-    text: ClassVar[str] = "BAR"
-
-
-class ClassB:
-    text: ClassVar[str] = "BAZ"
-
-
-class ClassC:
-    pass
-
-
-def func3(obj: BaseClass):
-    if isinstance(obj, (ClassA, ClassB)):
-        reveal_type(obj, expected_text="ClassA | ClassB")
-
-    if isinstance(obj, (ClassA, ClassB, ClassC)):
-        reveal_type(obj, expected_text="ClassA | ClassB")
-
-
-class A:
-    pass
-
-
-class B(A):
-    pass
-
-
-def func4(a: A, cls: Type[A]) -> None:
-    isinstance(a, cls)
-
-    # This should generate an error because it's always true.
-    isinstance(a, A)

package/src/tests/samples/unnecessaryIsSubclass1.py

@@ -1,22 +0,0 @@
-# This sample tests unnecessary issubclass error reporting.
-
-from typing import Union, Type
-
-
-def foo(p1: Type[int], p2: Union[Type[int], Type[str]]):
-    a = issubclass(p2, str)
-
-    b = issubclass(p2, (int, float))
-
-    # This should generate an error because this is always true.
-    c = issubclass(p2, (float, dict, int, str))
-
-    d = issubclass(p1, float)
-
-    e = issubclass(p2, (float, dict, int))
-
-    # This should generate an error because this is always true.
-    f = issubclass(p1, int)
-
-    # This should not generate an error because it's within an assert.
-    assert issubclass(p1, int)

package/src/tests/samples/unpack1.py

@@ -1,56 +0,0 @@
-# This sample tests the type checker's handling of the unpack operator.
-
-# pyright: strictListInference=true
-
-
-class Foo:
-    ...
-
-
-class Bar:
-    ...
-
-
-a = [1, "hello", 3.4, Foo()]
-
-b = [*a]
-
-
-def int_only(a: int):
-    ...
-
-
-for c in b:
-    if not isinstance(c, (float, str)):
-        # This should generate an error because c can
-        # be an int or foo.
-        int_only(c)
-
-        if not isinstance(c, Foo):
-            # This should not generate an error.
-            int_only(c)
-
-# This should generate an error
-x1 = *(1, 2, 3)
-
-x2 = 2, *(1, 2, 3)
-
-x3 = *(1, 2, 3), 2
-
-
-[d1, *e1, f1] = [1, 2, 3, 4]
-reveal_type(e1, expected_text="list[int]")
-
-[*d2, e2, f2] = [1, 2, 3, 4]
-reveal_type(d2, expected_text="list[int]")
-
-[d3, e3, *f3] = (1, 2, 3, 4)
-reveal_type(f3, expected_text="list[int]")
-
-[g1, g2, g3] = (1, 2, 3)
-
-# This should generate an error.
-[g1, g2, g3, g4] = (1, 2, 3)
-
-# This should generate an error.
-[g1, g2] = (1, 2, 3)

package/src/tests/samples/unpack2.py

@@ -1,27 +0,0 @@
-# This sample tests the creation of tuples from unpacked values.
-
-from typing import Any, List, Tuple
-
-
-def foo() -> Tuple[int, int, int]:
-    rest = (2, 3)
-    t = 1, *rest
-    return t
-
-
-def foo2() -> Tuple[int, int, int]:
-    rest = (3, 4)
-    t = 1, 2, *rest
-    # This should generate an error
-    return t
-
-
-def foo3() -> Tuple[Any, ...]:
-    rest = [1, 2, 3]
-    t = 1, 2, 3, *rest
-    requires_list(rest)
-    return t
-
-
-def requires_list(a: List[int]):
-    return None

package/src/tests/samples/unpack3.py

@@ -1,16 +0,0 @@
-# This sample tests the reporting of errors related to
-# unpack operators within tuple expressions not enclosed
-# in parentheses when used with return statements. Support
-# for this was added in Python 3.8.
-
-
-def test1():
-    a = [1, 2, 3]
-    b = (4, *a, 5)
-    return (4, *b, 5)
-
-
-def test2():
-    a = [1, 2, 3]
-    # This should generate an error for versions of Python <3.8
-    return 4, *a, 5

package/src/tests/samples/unpack4.py

@@ -1,15 +0,0 @@
-# This sample tests the handling of multiple unpack operators in a
-# star expression.
-
-a = [1, 2]
-b = ["3", "4"]
-
-# This should generate an error for versions of Python <3.9
-for x in *a, *b:
-    print(x)
-
-c = *a, *b
-print(c)
-
-# This should always generate an error.
-*a, *b = (1, 2, )

package/src/tests/samples/unreachable1.py

@@ -1,112 +0,0 @@
-# This sample tests the detection and reporting of unreachable code.
-
-from abc import abstractmethod
-import os
-import sys
-
-
-def func1():
-    """
-    Docstring
-    """
-    raise NotImplementedError()
-
-
-class Foo:
-    b: bool
-
-    @staticmethod
-    def method1():
-        """
-        Docstring
-        """
-        raise NotImplementedError("Not Implemented")
-
-    def method2(self, a: int):
-        """
-        Docstring
-        """
-        if a < 10 or self.b:
-            raise NotImplementedError()
-
-    @abstractmethod
-    def method3(self):
-        print(self.b)
-        raise RuntimeError()
-
-    def method4(self) -> None:
-        print(self.b)
-        raise RuntimeError()
-
-    def method5(self):
-        print(self.b)
-        raise RuntimeError()
-
-
-def func2():
-    func1()
-
-    # This should not be marked unreachable because NotImplementedError
-    # is special-cased.
-    return 3
-
-
-def func3(foo: Foo):
-    foo.method1()
-    return 3
-
-
-def func4(foo: Foo):
-    foo.method2(2)
-    return 3
-
-
-def func5(foo: Foo):
-    foo.method3()
-    return 3
-
-
-def func6(foo: Foo):
-    foo.method4()
-    return 3
-
-
-def func7(foo: Foo):
-    foo.method5()
-
-    # This should be marked as unreachable
-    return 3
-
-
-def func8():
-    raise NameError()
-
-
-def func9():
-    func8()
-
-    # This should be marked unreachable.
-    return 3
-
-
-def func10():
-    e = OSError()
-    a1 = os.name == "nt" and None == e.errno
-    reveal_type(a1, expected_text="bool")
-  
-    a2 = True and os.name == "nt"
-    reveal_type(a2, expected_text="bool")
-              
-    if os.name == "nt":
-        # This should be marked unreachable.
-        b = e.errno                            
-
-    if sys.version_info >= (4, 0):
-        # This should be marked unreachable.
-        b = e.errno
-         
-    return
-    # This should be marked unreachable.
-    b = e.errno
-
-    

package/src/tests/samples/unusedCallResult1.py

@@ -1,67 +0,0 @@
-# This sample tests the reportUnusedCallResult diagnostic rule.
-
-from typing import Any, Iterable, List, Union
-
-
-def func1():
-    pass
-
-
-def func2():
-    raise RuntimeError()
-
-
-def func3() -> Any:
-    pass
-
-
-def func4():
-    return 3
-
-
-def func5(a: int) -> Union[int, List[int]]:
-    if a < 0:
-        return 5
-    return [3]
-
-
-def func6() -> Iterable[int]:
-    return []
-
-
-func1()
-
-
-def aaa():
-    func2()
-
-
-func3()
-
-
-# This should generate a diagnostic if reportUnusedCallResult is enabled.
-func4()
-
-# This should generate a diagnostic if reportUnusedCallResult is enabled.
-func5(3)
-
-# This should generate a diagnostic if reportUnusedCallResult is enabled.
-func6()
-
-_, _ = func5(3), func6()
-
-_ = func5(3)
-
-_ = func5(func4())
-
-for _ in func6():
-    pass
-
-
-async def get_string_async() -> str:
-    return "A string"
-
-
-async def await_string() -> None:
-    # This should generate a diagnostic if reportUnusedCallResult is enabled.
-    await get_string_async()

package/src/tests/samples/unusedCoroutine1.py

@@ -1,23 +0,0 @@
-# This sample tests the reportUnusedCoroutine diagnostic rule.
-
-
-async def func1():
-    return 3
-
-
-async def func2() -> str:
-    return "5"
-
-
-async def func3():
-    await func1()
-    await func2()
-
-    # This should generate an error
-    func1()
-
-    # This should generate an error
-    func2()
-
-    _ = func1()
-    _ = func2()

package/src/tests/samples/unusedExpression1.py

@@ -1,34 +0,0 @@
-# This sample tests the reportUnusedExpression diagnostic rule.
-
-t = 1
-
-
-# This should generate a diagnostic.
--4
-
-# This should generate a diagnostic.
-4j
-
-# This should generate a diagnostic.
-4j + 4
-
-# This should generate a diagnostic.
-False
-
-# This should generate a diagnostic.
-t == 1
-
-# This should generate a diagnostic.
-t != 2
-
-# This should generate a diagnostic.
-t <= t
-
-# This should generate a diagnostic.
-not t
-
-# This should generate a diagnostic.
-None
-
-# This should generate a diagnostic.
-t

package/src/tests/samples/unusedVariable1.py

@@ -1,21 +0,0 @@
-# This sample tests the reportUnusedVariable diagnostic check.
-
-
-def func1(a: int):
-    x = 4
-
-    # This should generate an error if reportUnusedVariable is enabled.
-    y = x
-
-    _z = 4
-
-    _ = 2
-
-    __z__ = 5
-
-    if x + 1:
-        # This should generate an error if reportUnusedVariable is enabled.
-        z = 3
-    else:
-        # This should generate an error if reportUnusedVariable is enabled.
-        z = 5

package/src/tests/samples/variadicTypeVar1.py

@@ -1,51 +0,0 @@
-# This sample tests various conditions under which variadic
-# type variables can and cannot be used.
-
-# pyright: reportMissingModuleSource=false
-
-from typing import Generic, List, Tuple, TypeVar, Union
-from typing_extensions import TypeVarTuple, Unpack
-
-
-_T = TypeVar("_T")
-_Xs = TypeVarTuple("_Xs")
-
-
-class ClassA(Generic[_T, Unpack[_Xs]]):
-    def __init__(self, *args: Unpack[_Xs]) -> None:
-        reveal_type(args, expected_text="tuple[*_Xs@ClassA]")
-
-    # This should generate an error
-    def func2(self) -> Union[_Xs]:
-        ...
-
-    def func3(self) -> Tuple[Unpack[_Xs]]:
-        ...
-
-    # This should generate an error
-    def func4(self) -> Tuple[_Xs]:
-        ...
-
-    def func5(self) -> "ClassA[int, str, Unpack[_Xs]]":
-        ...
-
-    # This should be an error because List doesn't accept a variadic TypeVar.
-    x: List[_Xs] = []
-
-    # This should generate an error.
-    y: _Xs = ()
-
-    # This should generate an error.
-    z: Tuple[_Xs, ...]
-
-
-# This should generate an error.
-class ClassB(Generic[_Xs]):
-    ...
-
-
-# This should generate an error.
-x: List[_Xs] = []
-
-# This should generate an error.
-y: _Xs = ()

package/src/tests/samples/variadicTypeVar10.py

@@ -1,65 +0,0 @@
-# This sample tests the handling of variadic type variables when used
-# in conjunction with unpacked tuples.
-
-from __future__ import annotations
-from typing import Any, Generic, NewType, Tuple, TypeVar, Union
-from typing_extensions import TypeVarTuple, Unpack
-
-DType = TypeVar("DType")
-Shape = TypeVarTuple("Shape")
-
-Batch = NewType("Batch", int)
-Height = NewType("Height", int)
-Width = NewType("Width", int)
-Channels = NewType("Channels", int)
-
-
-class Array(Generic[DType, Unpack[Shape]]):
-    def __abs__(self) -> Array[DType, Unpack[Shape]]:
-        ...
-
-    def __add__(
-        self, other: Array[DType, Unpack[Shape]]
-    ) -> Array[DType, Unpack[Shape]]:
-        ...
-
-
-def process_batch_channels(x: Array[Batch, Unpack[Tuple[Any, ...]], Channels]) -> None:
-    ...
-
-
-def expect_variadic_array1(x: Array[Batch, Unpack[Shape]]) -> Union[Unpack[Shape]]:
-    ...
-
-
-def expect_variadic_array2(x: Array[Batch, Unpack[Tuple[Any, ...]]]) -> None:
-    ...
-
-
-def expect_precise_array(x: Array[Batch, Height, Width, Channels]) -> None:
-    ...
-
-
-def func1(x: Array[Batch, Height, Width, Channels]):
-    process_batch_channels(x)
-
-    expect_precise_array(x)
-
-
-def func2(y: Array[Batch, Channels]):
-    process_batch_channels(y)
-
-    # This should generate an error because the type args don't match.
-    expect_precise_array(y)
-
-
-def func3(z: Array[Batch]):
-    # This should generate an error because Channels is missing
-    process_batch_channels(z)
-
-
-def func4(y: Array[Any, Unpack[Tuple[Any, ...]]]):
-    reveal_type(y, expected_text="Array[Any, *tuple[Any, ...]]")
-    expect_variadic_array1(y)
-    expect_variadic_array2(y)
-    expect_precise_array(y)

package/src/tests/samples/variadicTypeVar11.py

@@ -1,72 +0,0 @@
-# This sample tests packing and unpacking operations with
-# variadic type variables. It is the same as variadicTypeVar4.py
-# except that it uses the * operator rather than Unpack.
-
-# pyright: reportMissingModuleSource=false
-
-from typing import Generic, NewType, Tuple, Union
-from typing_extensions import TypeVarTuple
-
-
-Shape = TypeVarTuple("Shape")
-
-
-class Array(Generic[*Shape]):
-    def __init__(self, *shape: *Shape):
-        self.shape = shape
-
-    def __abs__(self) -> "Array[*Shape]":
-        ...
-
-    def __add__(self, other: "Array[*Shape]") -> "Array[*Shape]":
-        ...
-
-
-Height = NewType("Height", int)
-Width = NewType("Width", int)
-x: Array[Height, Width] = Array(Height(480), Width(640))
-reveal_type(x.shape, expected_text="tuple[Height, Width]")
-reveal_type(abs(x), expected_text="Array[Height, Width]")
-reveal_type(x + abs(x), expected_text="Array[Height, Width]")
-
-
-_Xs = TypeVarTuple("_Xs")
-
-
-def func1(a: Tuple[*_Xs], b: Tuple[*_Xs]) -> Union[*_Xs]:
-    ...
-
-
-def func2(a: Tuple[int, *_Xs], b: Tuple[int, *_Xs]) -> Union[*_Xs]:
-    ...
-
-
-def func3(p1: Tuple[int], p2: Tuple[int, str]):
-    # This should generate an error
-    v1 = func1(p1, p2)
-
-    # This should generate an error
-    v2 = func2(p1, p2)
-
-    v3 = func2(p2, p2)
-    reveal_type(v3, expected_text="str")
-
-    v4 = func2((3, "hi"), p2)
-    reveal_type(v4, expected_text="str")
-
-    # This should generate an error
-    v5 = func2((3, 3), p2)
-
-
-def func4(a: int, *args: *_Xs, **kwargs: str) -> Tuple[int, *_Xs]:
-    ...
-
-
-c1 = func4(4, 5.4, 6j, b="3", c="5")
-reveal_type(c1, expected_text="Tuple[int, float, complex]")
-
-c2 = func4(4, b="3", c="5")
-reveal_type(c2, expected_text="Tuple[int]")
-
-# This should generate an error.
-c3 = func4(b="3", c="5")

package/src/tests/samples/variadicTypeVar12.py

@@ -1,26 +0,0 @@
-# This sample tests the case where a variadic TypeVar is used in
-# conjunction with a keyword-only parameter. It also tests protocol
-# invariance validation when a TypeVarTuple is used in the protocol
-# along with a non-variadic TypeVar.
-
-# pyright: strict
-
-from typing import Protocol, TypeVar
-from typing_extensions import TypeVarTuple, Unpack
-
-T = TypeVar("T")
-Ts = TypeVarTuple("Ts")
-
-
-class CallbackA(Protocol[*Ts, T]):
-    def __call__(self, *args: *Ts, keyed: T) -> tuple[Unpack[Ts], T]:
-        ...
-
-
-def example(a: int, b: str, *, keyed: bool) -> tuple[int, str, bool]:
-    return (a, b, keyed)
-
-
-a: CallbackA[int, str, bool] = example
-
-reveal_type(a, expected_text="(a: int, b: str, *, keyed: bool) -> tuple[int, str, bool]")