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

package/src/tests/samples/never2.py

@@ -1,43 +0,0 @@
-# This sample tests the handling of the "Never" type,
-# ensuring that it's treated as the same as NoReturn.
-
-from typing import NoReturn
-from typing_extensions import Never
-
-
-def assert_never1(val: Never) -> NoReturn:
-    raise Exception("Should never get here")
-
-
-def assert_never2(val: NoReturn) -> NoReturn:
-    raise Exception("Should never get here")
-
-
-# This should generate an error because Never doesn't accept type arguments.
-def assert_never3(val: Never[int]):
-    ...
-
-
-# This should generate an error because NoReturn doesn't accept type arguments.
-def assert_never4(val: NoReturn[int]):
-    ...
-
-
-def func1(val: str | int) -> str:
-    if isinstance(val, (str, int)):
-        return "str or int"
-    else:
-        assert_never1(val)
-
-
-def func2(val: str | int) -> str:
-    if isinstance(val, (str, int)):
-        return "str or int"
-    else:
-        assert_never2(val)
-
-
-reveal_type(assert_never1, expected_text="(val: Never) -> NoReturn")
-
-# This should generate an error.
-assert_never1(1)

package/src/tests/samples/newType1.py

@@ -1,34 +0,0 @@
-# This sample tests the type handler's handling of the
-# built-in NewType function.
-
-from typing import NewType, Type, TypeVar
-
-MyString = NewType("MyString", str)
-
-
-def must_take_string(p1: str):
-    pass
-
-
-must_take_string(MyString("hello"))
-
-
-def must_take_my_string(p1: MyString):
-    pass
-
-
-must_take_my_string(MyString("hello"))
-
-# This should generate an error because 'hello'
-# isn't a valid MyString.
-must_take_my_string("hello")
-
-
-_T = TypeVar("_T")
-
-
-def func1(x: Type[_T]) -> Type[_T]:
-    return x
-
-
-MyString2 = NewType("MyString2", func1(str))

package/src/tests/samples/newType2.py

@@ -1,25 +0,0 @@
-# This sample tests the special-case handle of the multi-parameter
-# form of the built-in "type" call.
-
-# pyright: strict
-
-X1 = type("X1", (object,), {})
-X2 = type("X2", (object,), {})
-
-
-class A(X1):
-    ...
-
-
-class B(X2, A):
-    ...
-
-
-# This should generate an error because the first arg is not a string.
-X3 = type(34, (object,))
-
-# This should generate an error because the second arg is not a tuple of class types.
-X4 = type("X4", 34)
-
-# This should generate an error because the second arg is not a tuple of class types.
-X5 = type("X5", (3,))

package/src/tests/samples/newType3.py

@@ -1,34 +0,0 @@
-# This sample tests that the type checker is properly synthesizing
-# a constructor for a NewType.
-
-from typing import NewType, Union
-
-
-UserId = NewType("UserId", int)
-
-# This should generate an error because the constructor
-# requires a single int.
-var1 = UserId()
-
-var2 = UserId(2)
-
-# This should generate an error because the constructor
-# requires a single int.
-var3 = UserId("2")
-
-# This should generate an error because the constructor
-# requires a single int.
-var4 = UserId(2, 3)
-
-
-def require_user_id(a: UserId):
-    ...
-
-
-require_user_id(var2)
-
-# this should generate an error.
-require_user_id(2)
-
-var5 = 4 + var2
-var6 = var2 * 2

package/src/tests/samples/newType4.py

@@ -1,8 +0,0 @@
-# This sample tests some error conditions for NewType usage.
-
-from typing import Literal, NewType, Sized, Union
-
-
-A = NewType("A", Union[int, str])
-B = NewType("B", Literal[1])
-C = NewType("B", Sized)

package/src/tests/samples/none1.py

@@ -1,29 +0,0 @@
-# This sample tests properties of the special NoneType.
-
-from typing import Hashable, Iterable, Optional
-
-a: Hashable = None
-
-# This should generate an error because None isn't iterable.
-b: Iterable = None
-
-c = None
-c.__class__
-c.__doc__
-
-
-def func1(a: Optional[int]):
-    a.__class__
-    a.__doc__
-
-
-def func2(x: type[None]):
-    ...
-
-
-func2(None.__class__)
-func2(type(None))
-
-reveal_type(type(None).__name__, expected_text="str")
-
-_ = type(None) == type(None)

package/src/tests/samples/none2.py

@@ -1,22 +0,0 @@
-# This sample checks that Type[None] is handled correctly.
-
-
-from typing import Type
-
-
-def func1(a: Type[None]) -> Type[str] | Type[None]:
-    reveal_type(a, expected_text="Type[None]")
-
-    # This should generate an error because None is
-    # not compatible with Type[None].
-    return None
-
-
-val1 = func1(type(None))
-
-if val1 is not None:
-    reveal_type(val1, expected_text="Type[str] | Type[None]")
-
-# This should generate an error because None isn't
-# assignable to Type[None].
-val2 = func1(None)

package/src/tests/samples/noreturn1.py

@@ -1,78 +0,0 @@
-# This sample tests the type checker's handling of the NoReturn annotation type.
-
-from typing import Callable, NoReturn
-
-
-# This should generate an error because the function
-# implicitly returns None.
-def func1() -> NoReturn:
-    pass
-
-
-def func2(x: bool) -> NoReturn:
-    if x:
-        # This should generate an error because the function
-        # explicitly returns a value.
-        return 4
-
-    raise Exception()
-
-
-def func3() -> NoReturn:
-    raise Exception()
-
-
-def func4(x: bool) -> str:
-    if x:
-        return "hello"
-    else:
-        func3()
-
-
-# This should generate an error because a generator
-# function must return an iterable type.
-def func5(x: bool) -> NoReturn:
-    if x:
-        # This should generate an error because the function
-        # explicitly yields a value.
-        yield 4
-
-    raise Exception()
-
-
-x1: Callable[[bool], bool] = func2
-
-
-async def func6() -> NoReturn:
-    ...
-
-
-async def func7() -> NoReturn:
-    await func6()
-
-
-class A:
-    def __init__(self) -> NoReturn:
-        ...
-
-
-def func8() -> NoReturn:
-    A()
-
-
-class B:
-    def __new__(cls) -> NoReturn:
-        ...
-
-
-def func9() -> NoReturn:
-    B()
-
-
-class C:
-    def __call__(self) -> NoReturn:
-        ...
-
-
-def func10() -> NoReturn:
-    C()()

package/src/tests/samples/noreturn2.py

@@ -1,37 +0,0 @@
-# This sample tests that the NoReturn logic is able to handle
-# union types in call expressions.
-
-from typing import NoReturn, Union
-
-
-def f() -> NoReturn:
-    raise TypeError
-
-
-class B(object):
-    def always_noreturn(self) -> NoReturn:
-        f()
-
-    def sometimes_noreturn(self) -> NoReturn:
-        raise TypeError
-
-
-class C(object):
-    def always_noreturn(self) -> NoReturn:
-        f()
-
-    def sometimes_noreturn(self) -> int:
-        return 0
-
-
-class A(object):
-    def __init__(self):
-        # Note the union type declaration here.
-        self._B_or_C: Union[B, C] = B()
-
-    def m3(self) -> NoReturn:
-        self._B_or_C.always_noreturn()
-
-    def m4(self) -> int:
-        x = self._B_or_C.sometimes_noreturn()
-        return x

package/src/tests/samples/noreturn3.py

@@ -1,16 +0,0 @@
-# This sample tests the case where a local NoReturn call depends
-# on the inferred type of a local variable.
-
-from typing import NoReturn
-
-
-class MyClass:
-    def no_return(
-        self,
-    ) -> NoReturn:
-        ...
-
-
-def client_code() -> NoReturn:
-    instance = MyClass()
-    instance.no_return()

package/src/tests/samples/noreturn4.py

@@ -1,29 +0,0 @@
-# This sample verifies that a `NoReturn` type can be assigned
-# to any other type.
-
-from typing import Callable, NoReturn, TypeVar
-
-
-_T = TypeVar("_T", int, str)
-
-
-def func1(x: Callable[[NoReturn], None]):
-    ...
-
-
-def func2(x: int) -> NoReturn:
-    ...
-
-
-def func3(x: _T) -> _T:
-    return x
-
-
-def func4(x: NoReturn):
-    v1: object = x
-    v2: int = x
-    v3: str | int = x
-    v4: None = x
-    v5: Callable[[int, str], str] = x
-    func1(func2)
-    func3(x)

package/src/tests/samples/operators1.py

@@ -1,101 +0,0 @@
-# This sample tests the type checker's ability to check
-# custom operator overrides.
-
-from typing import Union
-
-
-class A(object):
-    def __eq__(self, Foo):
-        return "equal"
-
-
-class B(object):
-    def __ne__(self, Bar):
-        return self
-
-    def __lt__(self, Bar):
-        return "string"
-
-    def __gt__(self, Bar):
-        return "string"
-
-    def __ge__(self, Bar):
-        return "string"
-
-    def __le__(self, Bar):
-        return "string"
-
-
-def needs_a_string(val: str):
-    pass
-
-
-def needs_a_string_or_bool(val: Union[bool, str]):
-    pass
-
-
-def test():
-    a = A()
-    needs_a_string(a == a)
-
-    # This should generate an error because there
-    # is no __ne__ operator defined, so a bool
-    # value will result.
-    needs_a_string(a != a)
-
-    if True:
-        a = B()
-
-    # At this point, a should be of type Union[Foo, Bar],
-    # so the == operator should return either a str or
-    # a bool.
-    needs_a_string_or_bool(a == a)
-
-    # This should generate an error.
-    needs_a_string(a == a)
-
-    # This should generate an error.
-    needs_a_string_or_bool(a != a)
-
-    b = B()
-    needs_a_string(b < b)
-    needs_a_string(b > b)
-    needs_a_string(b <= b)
-    needs_a_string(b >= b)
-
-
-class C:
-    def __getattr__(self, name: str, /):
-        if name == "__add__":
-            return lambda _: 0
-
-
-a = C()
-a.__add__
-
-# This should generate an error because __getattr__ is not used
-# when looking up operator overload methods.
-b = a + 0
-
-
-class D:
-    def __init__(self):
-        self.__add__ = lambda x: x
-
-
-d = D()
-
-# This should generate an error because __add__ is not a class variable.
-_ = d + d
-
-
-class E:
-    __slots__ = ("__add__",)
-
-    def __init__(self):
-        self.__add__ = lambda x: x
-
-
-e = E()
-
-_ = e + e

package/src/tests/samples/operators2.py

@@ -1,30 +0,0 @@
-# This sample tests the type checker's handling of chained
-# comparison operators.
-
-from datetime import datetime
-
-
-def requires_bool(val: bool):
-    pass
-
-
-date1 = datetime.now()
-date2 = datetime.now()
-date3 = datetime.now()
-
-foo1 = date1 < date2 <= date3
-requires_bool(foo1)
-
-int1 = 3
-foo2 = 2 < int1 < 5
-requires_bool(foo2)
-
-# This should generate an error because
-# int and datetime cannot be compared.
-foo3 = date1 < date2 < 3
-
-foo4 = (date1 < date2) < 3
-
-foo5 = "1" == "1" in "1"
-
-foo6 = "1" in "1" == "1"

package/src/tests/samples/operators3.py

@@ -1,8 +0,0 @@
-# This sample tests binary operators that act upon operands
-# with literal type arguments.
-
-# This should not generate an error even though the left side
-# is of type Tuple[Literal[1], Literal[0]] and the right side
-# is of type Tuple[Literal[0], Literal[0]]. They should both
-# be treated as Tuple[int, int].
-result = [(1, 0)] * 3 + [(0, 0)] * 3

package/src/tests/samples/operators4.py

@@ -1,22 +0,0 @@
-# This sample tests operator overloads for matrix multiply operations.
-
-
-class A:
-    pass
-
-
-class B:
-    def __rmul__(self, a: A):
-        pass
-
-    def __rmatmul__(self, a: A):
-        pass
-
-    def __matmul__(self, a: A):
-        pass
-
-
-a, b = A(), B()
-
-v1 = a @ b
-v2 = b @ a

package/src/tests/samples/operators5.py

@@ -1,5 +0,0 @@
-# This sample tests the parsing of the deprecated <> operator.
-
-# This should generate a single error, not a cascade of errors.
-if 3 <> 5:
-    print("OK")

package/src/tests/samples/operators6.py

@@ -1,10 +0,0 @@
-# This sample tests whether metaclasses that support operator
-# magic methods work correctly.
-
-import ctypes
-
-v1 = ctypes.POINTER(ctypes.c_bool) * 3
-reveal_type(v1, expected_text="Type[Array[pointer[c_bool]]]")
-
-v2 = 3 * ctypes.POINTER(ctypes.c_bool)
-reveal_type(v2, expected_text="Type[Array[pointer[c_bool]]]")

package/src/tests/samples/operators7.py

@@ -1,24 +0,0 @@
-# This sample tests the handling of binary operators when used with
-# generic types.
-
-from typing import TypeVar
-
-_TInt = TypeVar("_TInt", bound=int)
-
-
-def func1(n: _TInt) -> _TInt:
-    x = n + 1
-    reveal_type(x, expected_text="int")
-
-    # This should generate an error.
-    return x
-
-
-_TIntOrStr = TypeVar("_TIntOrStr", int, str)
-
-
-def func2(n: _TIntOrStr) -> _TIntOrStr:
-    x = n + n
-    reveal_type(x, expected_text="int* | str*")
-
-    return x

package/src/tests/samples/operators8.py

@@ -1,125 +0,0 @@
-# This sample tests various "literal math" binary and unary operations that
-# are applied when all operands are literal types with the same associated
-# class.
-
-from typing import Literal
-
-
-def func1(a: Literal[1, 2], b: Literal[0, 4], c: Literal[3, 4]):
-    c1 = a * b + c
-    reveal_type(c1, expected_text="Literal[3, 4, 7, 8, 11, 12]")
-
-    c2 = a // 0
-    reveal_type(c2, expected_text="int")
-
-    c3 = a % 0
-    reveal_type(c3, expected_text="int")
-
-    c4 = ((a * 1000) % 39) // c
-    reveal_type(c4, expected_text="Literal[8, 6, 3, 2]")
-
-    c5 = a + True
-    reveal_type(c5, expected_text="int")
-
-    c1 -= 5
-    reveal_type(c1, expected_text="Literal[-2, -1, 2, 3, 6, 7]")
-
-    c1 = -c1
-    reveal_type(c1, expected_text="Literal[2, 1, -2, -3, -6, -7]")
-
-    c1 = +c1
-    reveal_type(c1, expected_text="Literal[2, 1, -2, -3, -6, -7]")
-
-    c6 = 1
-    for _ in range(100):
-        c6 += a
-        reveal_type(c6, expected_text="int")
-
-
-def func2(cond: bool):
-    c1 = "Hi " + ("Steve" if cond else "Amy")
-    reveal_type(c1, expected_text="Literal['Hi Steve', 'Hi Amy']")
-
-
-def func3(cond: bool):
-    c1 = b"Hi " + (b"Steve" if cond else b"Amy")
-    reveal_type(c1, expected_text="Literal[b'Hi Steve', b'Hi Amy']")
-
-
-def func4(a: Literal[True], b: Literal[False]):
-    c1 = a and b
-    reveal_type(c1, expected_text="Literal[False]")
-
-    c2 = a and a
-    reveal_type(c2, expected_text="Literal[True]")
-
-    c3 = a or b
-    reveal_type(c3, expected_text="Literal[True]")
-
-    c4 = not a
-    reveal_type(c4, expected_text="Literal[False]")
-
-    c5 = not b
-    reveal_type(c5, expected_text="Literal[True]")
-
-    c6 = not b and not a
-    reveal_type(c6, expected_text="Literal[False]")
-
-    c7 = not b or not a
-    reveal_type(c7, expected_text="Literal[True]")
-
-    c8 = b
-    reveal_type(c8, expected_text="Literal[False]")
-    while True:
-        c8 = not c8
-        reveal_type(c8, expected_text="bool")
-
-
-mode = Literal[
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "z",
-    "y",
-    "z",
-]
-
-
-def func5(
-    a: mode, b: mode, c: mode, d: mode, e: mode, f: mode, g: mode, h: mode, i: mode
-):
-    # Make sure this degenerate case falls back to "str".
-    reveal_type(a + b + c + d + e + f + g + h + i, expected_text="str")
-
-
-def func6(x: Literal[1, 3, 5, 7, 11, 13]):
-    y = x
-    y *= x
-
-    reveal_type(
-        y,
-        expected_text="Literal[1, 3, 5, 7, 11, 13, 9, 15, 21, 33, 39, 25, 35, 55, 65, 49, 77, 91, 121, 143, 169]",
-    )
-
-    y *= x
-    reveal_type(y, expected_text="int")