@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/never2.py

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,8 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,78 @@
+# 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

@@ -0,0 +1,37 @@
+# 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

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,101 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,8 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,5 @@
+# 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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,125 @@
+# 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")