@zzzen/pyright-internal 1.1.255 → 1.2.0-beta

package/src/tests/samples/await1.py

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

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

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

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

package/src/tests/samples/call1.py

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

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

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

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

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

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

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

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

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

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