@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/await1.py

@@ -0,0 +1,23 @@
+# This sample validates that the await keyword participates in
+# bidirectional type inference.
+
+from typing import Callable, TypeVar, Generic
+
+T = TypeVar("T")
+AnyMsg = TypeVar("AnyMsg", bound="Msg")
+
+
+class Msg(Generic[T]):
+    body: T
+
+
+class Request:
+    id: int
+
+
+async def func1(check: "Callable[[AnyMsg], bool]") -> AnyMsg:
+    ...
+
+
+async def main():
+    _: Msg[Request] = await func1(check=lambda msg: (msg.body.id == 12345))

package/src/tests/samples/await2.py

@@ -0,0 +1,25 @@
+# This sample tests that types defined by type variables can be
+# awaited.
+
+import asyncio
+from typing import Generator, Any
+
+
+class MyAwaitable:
+    def __await__(self) -> Generator[Any, None, int]:
+        async def foo() -> int:
+            return 1
+
+        return foo().__await__()
+
+    async def foo(self) -> int:
+        return await self
+
+
+async def main() -> None:
+    p = MyAwaitable()
+    print(await p.foo())
+    print(await p)
+
+
+asyncio.run(main())

package/src/tests/samples/badToken1.py

@@ -0,0 +1,6 @@
+# This sample uses a non-breaking space, which should generate errors in
+# the tokenizer, parser and type checker.
+
+# The space between "import" and "sys" is a non-breaking UTF8 character.
+import sys
+

package/src/tests/samples/builtins1.py

@@ -0,0 +1,2 @@
+# This file is intentionally blank. It's used to test
+# the implicitly-imported builtins module and its symbols.

package/src/tests/samples/call1.py

@@ -0,0 +1,93 @@
+# This sample tests various function type checking
+# behavior including arg/param matching.
+
+from typing import Callable
+
+# ------------------------------------------------------
+# Test function type matching
+
+
+class FooBase:
+    pass
+
+
+class Foo(FooBase):
+    pass
+
+
+class Bar(Foo):
+    pass
+
+
+def needs_function1(callback: Callable[[Foo], Foo]):
+    pass
+
+
+def callback1():
+    pass
+
+
+def callback2(a: Foo) -> Foo:
+    return Foo()
+
+
+def callback3(a: Foo) -> str:
+    return "1"
+
+
+def callback4(a: Foo, b: Foo) -> Foo:
+    return Foo()
+
+
+def callback5(a: Foo, b: int = 3) -> Foo:
+    return Foo()
+
+
+def callback6(*a) -> Foo:
+    return Foo()
+
+
+def callback7(a: str) -> Foo:
+    return Foo()
+
+
+def callback8(a: Bar) -> Foo:
+    return Foo()
+
+
+def callback9(a: FooBase) -> Foo:
+    return Foo()
+
+
+# This should generate an error because callback1
+# takes no parameters.
+needs_function1(callback1)
+
+needs_function1(callback2)
+
+# This should generate an error because the return
+# type of callback3 doesn't match.
+needs_function1(callback3)
+
+# This should generage an error because callback4
+# takes too many parameters.
+needs_function1(callback4)
+
+needs_function1(callback5)
+needs_function1(callback6)
+
+# This should fail because the parameter is the
+# wrong type.
+needs_function1(callback7)
+
+# This should fail because the parameter is the
+# wrong type.
+needs_function1(callback8)
+
+needs_function1(callback9)
+
+
+import typing
+
+# This should generate an error because modules are not callable.
+typing()

package/src/tests/samples/call2.py

@@ -0,0 +1,118 @@
+# This sample tests function parameter matching logic.
+
+
+from typing import Any, Dict, List
+
+
+def func1(a: int, *b: int):
+    pass
+
+
+func1(3)
+func1(3, 4)
+func1(3, *[1, 2, 3])
+
+# This should generate an error
+func1(3, "hello")
+
+# This should generate an error
+func1(3, 5, 2, "str")
+
+# This should generate an error
+func1("hello", 3)
+
+# This should generate an error
+str_list = ["he", "2", "3"]
+func1(3, *str_list)
+
+
+def func2(a: str, **b: int):
+    pass
+
+
+func2("hi")
+func2("hi", b=3, c=4, d=5)
+
+str_dict = {"a": "3", "b": "2"}
+func2("hi", **str_dict)
+
+
+# This should generate a type error
+func2("hi", 3)
+
+# This should generate a type error
+func2("hi", b="hi")
+
+
+def func4(*args: int):
+    pass
+
+
+def func5(a: int, *args):
+    pass
+
+
+tuple1 = (2, 3)
+func4(*tuple1)
+func5(*tuple1)
+
+# This should generate an error because a is assigned twice.
+func2(a="", a="")
+
+# This should generate an error because c is assigned twice.
+func2("", c=4, d=5, c=5)
+
+
+def func6(param1: int, param2: str):
+    pass
+
+
+def func7(*args: Any, param0: int, param1: int, param2: str):
+    func6(*args, param1=param1, param2=param2)
+
+    func6(param0, param2=param2)
+
+    # This should generate two errors because param0 has no match
+    # and param2 is missing.
+    func6(param0, param1=param1)
+
+
+def func8(
+    y: str,
+    z: bool = ...,
+) -> None:
+    ...
+
+
+kwargs1: Dict[str, int] = {}
+# This should generate an error because int is not compatible with str.
+func8(z=False, **kwargs1)
+
+
+class MyStr(str):
+    ...
+
+
+kwargs2: Dict[MyStr, MyStr] = {}
+func8(z=False, **kwargs2)
+
+
+def func9(
+    x: int,
+    y: str,
+    *,
+    a: str = ...,
+    b: str,
+    c: str,
+) -> None:
+    ...
+
+
+kwargs3: Dict[str, str] = {}
+func9(0, "", **kwargs3)
+
+args4: List[str] = ["hi"]
+func9(0, *args4, **kwargs3)
+
+# This should generate an error
+func9(*args4, **kwargs3)

package/src/tests/samples/call3.py

@@ -0,0 +1,168 @@
+# This sample tests the Python 3.8 "positional-only parameter" feature.
+
+from typing import Any, Dict, Protocol, Tuple
+
+
+def f0(a: int, b: int):
+    return 3
+
+
+def f1(a: int, b: int, /):
+    return 3
+
+# This should generate an error because only one
+# '/' parameter is allowed.
+def f2(a: int, /, b: int, /):
+    return 3
+
+def f3(a: int, /, b: int):
+    return 3
+
+def f4(a: int, /, b: int, *, c: int):
+    return 3
+
+# This should generate an error because a '/'
+# parameter shouldn't appear after '*'.
+def f5(a: int, *, b: int, /, c: int):
+    return 3
+
+# This should generate an error because a '/'
+# parameter cannot be the first in a param list.
+def f6(/, a: int, *, b: int):
+    return 3
+
+
+f0(2, 3)
+
+f1(2, 3)
+
+# This should generate an error because b
+# is a position-only parameter.
+f1(2, b=3)
+
+# This should generate an error because a and b
+# are position-only parameters.
+f1(a=2, b=3)
+
+f2(2, 3)
+
+# This should generate an error.
+f2(a=2, b=3)
+
+f3(2, 3)
+f3(2, b=3)
+
+# This should generate 1 error because a is a
+# position-only parameter.
+f3(a=2, b=3)
+
+f4(1, 2, c=3)
+f4(1, b=2, c=3)
+
+# This should generate an error because c is a
+# keyword-only parameter.
+f4(1, 2, 3)
+
+# This should generate an error because a is a
+# positional-only parameter.
+f4(a=1, b=2, c=3)
+
+# This will an error because of the bad
+# declaration. Test to make sure we don't crash.
+f5(1, b=2, c=3)
+
+f6(1, b=2)
+f6(a=1, b=2)
+
+class A:
+    def f(self, g: bool = False, /, **kwargs) -> None:
+        ...
+
+a = A()
+
+a.f(hello="world")
+
+
+def f7(name: str, /, **kwargs: Any):
+    return 3
+
+f7("hi", name=3)
+
+# This should generate an error
+f7("hi", name=3, name=4)
+
+
+class P1(Protocol):
+    def f(self, x: Any, /):
+        ...
+
+
+class C1:
+    def f(
+        self,
+        y: Any,
+    ):
+        ...
+
+
+c1: P1 = C1()
+
+
+class P2(Protocol):
+    def f(self, x: Any):
+        ...
+
+
+class C2:
+    def f(self, y: Any, /):
+        ...
+
+
+# This should generate an error
+c2: P2 = C2()
+
+
+def f8(a: int, b: int = 3, /):
+    ...
+
+
+kwargs: Dict[str, Any] = {}
+
+# This should generate an error
+f8()
+
+# This should generate an error
+f8(**kwargs)
+
+
+f8(0, **kwargs)
+
+def f9(*, c: int):
+    pass
+
+# This should generate an error because it is missing a keyword
+# argument for keyword parameter "c".
+f9(*[1, 2, 3])
+
+
+# This should generate an error because "/" cannot be used after "*args"
+def f10(x, *args, /, y):
+    pass
+
+# This should generate an error because "*" cannot be used after "*args"
+def f11(x, *args, *, y):
+    pass
+
+
+
+def f12(a: int, b: str, /):
+    ...
+
+
+def f13(v: Tuple[int, str]):
+    f12(*v)
+
+def f14(v: Tuple[int]):
+    # This should generate an error because parameter "b" has
+    # no corresponding argument.
+    f12(*v)

package/src/tests/samples/call4.py

@@ -0,0 +1,13 @@
+# This sample tests that the TypeVar matching logic for
+# functions is working correctly.
+
+from typing import List
+
+a: List[str] = ["a", "bc"]
+
+# This should work because the "sorted" is defined
+# with the first parameter of Iterable[_T] and the
+# 'key' parameter Callable[[_T], Any]. Since "len"
+# is a function that takes a "Sized" and "str" is
+# a "Sized", the result of this should be List[str].
+b: List[str] = sorted(a, key=len)

package/src/tests/samples/call5.py

@@ -0,0 +1,95 @@
+# This sample tests handling of unpack operators used
+# for arguments that are of a specified length (specifically,
+# tuples with a specified list of elements types).
+
+from typing import NamedTuple, List, Tuple
+
+X = NamedTuple("X", [("a", int), ("b", str), ("c", str)])
+
+q0: List[Tuple[int, str, str]] = [(1, "", ""), (2, "", "")]
+
+[X(*item) for item in q0]
+
+
+q1: List[Tuple[int, str, float]] = [(1, "a", 3), (2, "b", 4), (3, "c", 5)]
+
+# This should generate an error because the items in q1 are not the
+# right type for the X constructor.
+[X(*item) for item in q1]
+
+
+q2: List[Tuple[int, str]] = [(1, "1"), (2, "2"), (3, "3")]
+
+# This should generate an error because the items in q2 contain only
+# two elements, and we need three to populate all three parameters
+# in the X constructor.
+[X(*item) for item in q2]
+
+
+q3: List[Tuple[int, str, str, float]] = [
+    (1, "a", "3", 4),
+    (2, "b", "4", 5),
+    (3, "c", "5", 6),
+]
+
+# This should generate an error because the items in q3 contain
+# four elements, and we need three to populate all parameters
+# in the X constructor.
+[X(*item) for item in q3]
+
+
+q4: List[Tuple[int, ...]] = [
+    (1, 3),
+    (2, 5),
+    (3, 6),
+]
+
+# This should generate two errors because int isn't assignable to parameter
+# b or c.
+[X(*item) for item in q4]
+
+
+Y = NamedTuple("Y", [("a", str), ("b", str), ("c", str)])
+
+q5: List[Tuple[str, ...]] = [
+    ("a", "b"),
+    ("a", "b"),
+]
+
+[Y(*item) for item in q5]
+
+
+class Z(NamedTuple):
+    a: list[str]
+    b: list[int]
+
+
+q6 = Z(["1"], [3])
+
+for a, b in zip(*q6):
+    reveal_type(a, expected_text="str")
+    reveal_type(b, expected_text="int")
+
+
+def func1(a: list[str], c: list[int]):
+    ...
+
+
+func1(*q6)
+
+
+class ABC(NamedTuple):
+    a: float
+    b: float
+    c: float
+
+    def to_rgba(self) -> "ABC":
+        return ABC(*self)
+
+
+class AB(NamedTuple):
+    a: float
+    b: float
+
+    def to_abc(self) -> ABC:
+        return ABC(*self, 1)

package/src/tests/samples/call6.py

@@ -0,0 +1,35 @@
+# This sample tests the handling of unpack operators
+# used in argument expressions when used in conjunction with
+# Tuples and *args parameters.
+
+
+from typing import Tuple
+
+
+def foo1(a: int, b: int):
+    pass
+
+
+def foo2(*args: int):
+    pass
+
+
+fixed_tuple_0 = ()
+foo1(*fixed_tuple_0, 2)
+foo2(*fixed_tuple_0, 2)
+
+fixed_tuple_1 = (1,)
+foo1(*fixed_tuple_1, 2)
+foo2(*fixed_tuple_1, 2)
+
+fixed_tuple_3 = (1, 3, 5)
+
+# This should generate an error because there
+# are too many parameters.
+foo1(*fixed_tuple_3, 2)
+foo2(*fixed_tuple_3, 2)
+
+homogen_tuple: Tuple[int, ...] = (1, 5, 3)
+
+foo2(*homogen_tuple)
+foo2(*homogen_tuple, 2)

package/src/tests/samples/call7.py

@@ -0,0 +1,57 @@
+# This sample tests the handling of an unpacked TypedDict passed as
+# an argument to a function.
+
+from typing import TypedDict
+
+
+class TD1(TypedDict):
+    arg1: int
+    arg2: str
+
+
+class TD2(TD1):
+    arg3: float
+
+
+def func1(arg1: int, arg2: str):
+    pass
+
+
+def func2(arg1: int, arg2: str, arg3: float):
+    pass
+
+
+def func3(arg1: int, arg2: str, **kwargs: float):
+    pass
+
+
+def func4(arg1: int, arg2: str, **kwargs: int):
+    pass
+
+
+td1: TD1 = {"arg1": 10, "arg2": "something"}
+td2: TD2 = {"arg1": 10, "arg2": "something", "arg3": 3.4}
+
+func1(**td1)
+
+# This should generate an error because "arg1" is already assigned
+func1(arg1=3, **td1)
+
+# This should generate an error because "arg3" isn't provided
+func1(**td2)
+
+# This should generate an error because "arg3" isn't matched
+func2(**td1)
+
+func2(**td2)
+
+
+func3(**td1)
+
+func3(**td2)
+
+func4(**td1)
+
+# This should generate an error because "arg3" cannot be matched
+# due to the type of the **kwargs parameter.
+func4(**td2)

package/src/tests/samples/callSite1.py

@@ -0,0 +1,6 @@
+# This sample tests pyright's ability to perform return type
+# analysis of functions based on call-site arguments.
+
+# This function has no type annotations
+def add(a, b):
+    return a + b

package/src/tests/samples/callSite2.py

@@ -0,0 +1,12 @@
+# This sample tests pyright's ability to perform return type
+# analysis of functions based on call-site arguments.
+
+# pyright: strict
+
+from .callSite1 import add  # pyright: ignore[reportUnknownVariableType]
+
+must_be_int = add(1, 2)
+result1: int = must_be_int
+
+must_be_str = add("hi", "there")
+result2: str = must_be_str

package/src/tests/samples/callable1.py

@@ -0,0 +1,53 @@
+# This sample tests the type checker's handling of the
+# builtin "Callable" class.
+
+from typing import Callable
+
+# Test forward declaration
+Callable1 = Callable[["A"], None]
+
+
+class A:
+    pass
+
+
+Callable2 = Callable[[A], None]
+
+
+def func1(a: Callable1):
+    a(A())
+
+
+def func2(a: Callable2):
+    a(A())
+
+
+# Test Callable with ...
+Callable3 = Callable[..., int]
+
+
+def func3(a: Callable3) -> int:
+    return a(1, 2, 3) + a() + a("hello") + a([])
+
+
+# This should generate an error (... not allowed in param list)
+Callable4 = Callable[[...], int]
+
+# This should generate an error (too many arguments)
+Callable5 = Callable[..., int, int]
+
+
+# Test Callable with no parameters
+Callable6 = Callable[[], str]
+
+
+def func6(a: Callable6):
+    a()
+    # This should generate an error
+    a(1)
+
+
+def func7(a: Callable):
+    reveal_type(a, expected_text="(...) -> Unknown")
+    b = a(3, 4, 5)
+    reveal_type(b, expected_text="Unknown")