@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/kwargsUnpack1.py

@@ -0,0 +1,116 @@
+# This sample tests the handling of Unpack[TypedDict] when used with
+# a **kwargs parameter in a function signature.
+
+from typing import Protocol, TypedDict
+from typing_extensions import NotRequired, Required, Unpack
+
+
+class TD1(TypedDict):
+    v1: Required[int]
+    v2: NotRequired[str]
+
+
+class TD2(TD1):
+    v3: Required[str]
+
+
+def func1(**kwargs: Unpack[TD2]) -> None:
+    v1 = kwargs["v1"]
+    reveal_type(v1, expected_text="int")
+
+    # This should generate an error because v2 might not be present.
+    kwargs["v2"]
+
+    if "v2" in kwargs:
+        v2 = kwargs["v2"]
+        reveal_type(v2, expected_text="str")
+
+    v3 = kwargs["v3"]
+    reveal_type(v3, expected_text="str")
+
+
+reveal_type(func1, expected_text="(**kwargs: **TD2) -> None")
+
+
+def func2(v1: int, **kwargs: Unpack[TD1]) -> None:
+    pass
+
+
+def func3():
+    # This should generate an error because it is
+    # missing required keyword arguments.
+    func1()
+
+    func1(v1=1, v2="", v3="5")
+
+    td2 = TD2(v1=2, v3="4")
+    func1(**td2)
+
+    # This should generate an error because v4 is not in TD2.
+    func1(v1=1, v2="", v3="5", v4=5)
+
+    # This should generate an error because args are passed by position.
+    func1(1, "", "5")
+
+    my_dict: dict[str, str] = {}
+    # This should generate an error because it's an untyped dict.
+    func1(**my_dict)
+
+    func1(**{"v1": 2, "v3": "4", "v4": 4})
+
+    func2(**td2)
+
+    # This should generate an error because v1 is already specified.
+    func1(v1=2, **td2)
+
+    # This should generate an error because v1 is already specified.
+    func2(1, **td2)
+
+    # This should generate an error because v1 is matched to a
+    # named parameter and is not available for kwargs.
+    func2(v1=1, **td2)
+
+
+class TDProtocol1(Protocol):
+    def __call__(self, *, v1: int, v3: str) -> None:
+        ...
+
+
+class TDProtocol2(Protocol):
+    def __call__(self, *, v1: int, v3: str, v2: str = "") -> None:
+        ...
+
+
+class TDProtocol3(Protocol):
+    def __call__(self, *, v1: int, v2: int, v3: str) -> None:
+        ...
+
+
+class TDProtocol4(Protocol):
+    def __call__(self, *, v1: int) -> None:
+        ...
+
+
+class TDProtocol5(Protocol):
+    def __call__(self, v1: int, v3: str) -> None:
+        ...
+
+
+class TDProtocol6(Protocol):
+    def __call__(self, **kwargs: Unpack[TD2]) -> None:
+        ...
+
+
+v1: TDProtocol1 = func1
+v2: TDProtocol2 = func1
+
+# This should generate an error because v2 is the wrong type.
+v3: TDProtocol3 = func1
+
+# This should generate an error because v3 is missing.
+v4: TDProtocol4 = func1
+
+# This should generate an error because parameters are positional.
+v5: TDProtocol5 = func1
+
+v6: TDProtocol6 = func1

package/src/tests/samples/lambda1.py

@@ -0,0 +1,77 @@
+# This sample tests type checking for lambdas and their parameters.
+from typing import Any, Callable, Iterable, Optional, TypeVar
+
+#------------------------------------------------------
+# Test basic lambda matching
+
+def needs_function(callback: Callable[[str, int], str]):
+    pass
+
+needs_function(lambda x, y:x)
+
+# This should generate an error because the lambda doesn't
+# accept two parameters.
+needs_function(lambda x:x)
+
+
+#------------------------------------------------------
+# Test lambda matching when dest includes default parameter values
+
+def needs_function2(callback: Callable[[str, int], str]):
+    pass
+
+needs_function(lambda x, y:x)
+
+
+#------------------------------------------------------
+# Test parameter rules for lambdas
+
+# This should generate an error because a parameter with
+# no default follows a parameter with a default.
+lambda2 = lambda x=1, y:y
+
+lambda3 = lambda x, y=5:y
+lambda3(1)
+lambda3(1, 2)
+
+lambda4 = lambda x, *y, z:y
+
+
+#------------------------------------------------------
+# Test calling of lambdas
+
+lambda1 = lambda x, y:x
+lambda1(1, 2)
+
+# This should generate an error because the lambda doesn't
+# accept three parameters.
+lambda1(1, 2, 3)
+
+lambda4(1, z=3)
+lambda4(1, 3, 4, 5, 6, z=3)
+
+# This should generate an error because the arguments
+# don't match the parameter list.
+lambda4(1, 3)
+
+# This should generate an error because the arguments
+# don't match the parameter list (no named value for z).
+lambda4(1, 3, 4)
+
+
+#------------------------------------------------------
+# Test generic parameter matching in lambdas
+
+_T1 = TypeVar('_T1')
+
+def may_need_function_generic(callback: Optional[Callable[[_T1], _T1]]):
+    pass
+
+may_need_function_generic(lambda x: x)
+
+
+def reduce(function: Callable[[_T1, _T1], _T1], sequence: Iterable[_T1]) -> _T1:
+    ...
+
+
+a: object = reduce((lambda x, y: x * y), [1, 2, 3, 4])

package/src/tests/samples/lambda2.py

@@ -0,0 +1,26 @@
+# This sample verifies that the type checker properly handles
+# lambdas with position-only and keyword-only markers.
+
+from typing import Callable
+
+foo1: Callable[[int], int] = lambda x, /: x + 1
+
+# This should generate an error because there are too few
+# parameters provided by the lambda.
+foo2: Callable[[int, int], int] = lambda x, /: x + 1
+
+# This should generate an error because there are too many
+# parameters provided by the lambda.
+foo3: Callable[[int, int], int] = lambda x, /, y, z: x + 1
+
+# This should generate an error because there is no named
+# parameter y.
+foo4: Callable[[int, int], int] = lambda x, *, y: x + y + 1
+
+# This should generate an error because there are too few
+# parameters provided by the lambda.
+foo5: Callable[[int, int, int], int] = lambda x, *, y: x + y + 1
+
+# This should generate an error because there are too many
+# parameters provided by the lambda.
+foo6: Callable[[int], int] = lambda x, *, y: x + y + 1

package/src/tests/samples/lambda3.py

@@ -0,0 +1,34 @@
+# This sample tests the handling of default parameter value
+# expressions in a lambda.
+
+
+from typing import Callable, Protocol
+
+
+def test1():
+    var = 1
+
+    lambda _=var: ...
+
+
+def test2():
+    # This should generate an error because var2 isn't defined.
+    lambda _=var2: ...
+
+
+def test3():
+    var = 0
+    lambda var=var: ...
+
+
+class MyCallback(Protocol):
+    def __call__(self, y: int, a: int = 0) -> bool:
+        ...
+
+
+lambda1: Callable[[int, int], bool] = lambda y, a=0: a == y
+lambda2: MyCallback = lambda y, a=0: a == y
+
+lambda1(20)
+lambda2(20)
+lambda2(20, 30)

package/src/tests/samples/lambda4.py

@@ -0,0 +1,70 @@
+# This sample tests the case where a lambda is assigned to
+# a union type that contains multiple callables.
+
+from typing import Callable, Protocol, Union
+
+
+U1 = Union[Callable[[int, str], bool], Callable[[str], bool]]
+
+
+def accepts_u1(cb: U1) -> U1:
+    return cb
+
+
+def callback_1(p0: int, p1: str):
+    return True
+
+
+def callback_2(p0: str):
+    return True
+
+
+def callback_3(*p0: str):
+    return True
+
+
+accepts_u1(lambda s: s.startswith("hello"))
+accepts_u1(lambda i, s: i > 0 and s.startswith("hello"))
+accepts_u1(lambda *i: True)
+accepts_u1(callback_1)
+accepts_u1(callback_2)
+accepts_u1(callback_3)
+
+# This should generate an error
+accepts_u1(lambda a, b, c: True)
+
+
+class Callable1(Protocol):
+    def __call__(self, p0: int, p1: str) -> bool:
+        ...
+
+
+class Callable2(Protocol):
+    def __call__(self, p0: str) -> bool:
+        ...
+
+
+class Callable3(Protocol):
+    def __call__(self, *p0: str) -> bool:
+        ...
+
+
+class Callable4(Protocol):
+    def __call__(self, p0: int, p1: str, *p2: str) -> bool:
+        ...
+
+
+U2 = Union[Callable1, Callable2, Callable3, Callable4]
+
+
+def accepts_u2(cb: U2) -> U2:
+    return cb
+
+
+accepts_u2(lambda p0: p0.startswith("hello"))
+accepts_u2(lambda p0, p1: p0 > 0 and p1.startswith("hello"))
+accepts_u2(lambda *i: True)
+accepts_u2(lambda p0, p1, *p2: True)
+accepts_u2(callback_1)
+accepts_u2(callback_2)
+accepts_u2(callback_3)

package/src/tests/samples/lambda5.py

@@ -0,0 +1,23 @@
+# This sample tests the case where a lambda's type is determined using
+# bidirectional type inference and one or more of the parameters
+# corresponds to a generic type.
+
+from typing import Callable, TypeVar, Generic, Any
+
+T = TypeVar("T")
+MsgT = TypeVar("MsgT", bound="Msg[Any]")
+
+
+class Msg(Generic[T]):
+    body: T
+
+
+class Request:
+    ...
+
+
+def check(func: "Callable[[MsgT, int], object]") -> MsgT:
+    ...
+
+
+notification: Msg[Request] = check(lambda msg, foo: (msg.body, foo))

package/src/tests/samples/lambda6.py

@@ -0,0 +1,15 @@
+# This sample validates that lambdas declared within a class
+# body do not reference class-scoped variables within the
+# lambda return expression.
+
+
+var1 = [1, 2]
+
+
+class A:
+    x1 = lambda: var1
+
+    var2 = [1, 2]
+
+    # This should generate an error.
+    x2 = lambda: var2

package/src/tests/samples/lines1.py

@@ -0,0 +1,14 @@
+# This sample tests that the tokenizer properly handles
+# line feeds.
+
+"""
+This is a multi-line comment \
+with escape characters.
+"""
+
+# This is a raw string with an escaped EOL.
+foo = r"\
+"
+
+# The final token should be on line 14
+bar = foo

package/src/tests/samples/list1.py

@@ -0,0 +1,90 @@
+# This sample tests type inference for list expressions.
+
+# pyright: strict, reportUnknownVariableType=false
+
+from typing import (
+    Any,
+    Collection,
+    Dict,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    TypeVar,
+)
+
+
+v1 = [1, 2, 3]
+reveal_type(v1, expected_text="list[int]")
+
+v2 = [1, 3.4, "hi"]
+reveal_type(v2, expected_text="list[int | float | str]")
+
+v3 = []
+reveal_type(v3, expected_text="list[Unknown]")
+
+v4: List[object] = []
+
+v5: object = []
+
+v6: Sequence[float] = [3, 4, 5]
+
+v7: Collection[object] = [[]]
+
+
+_T = TypeVar("_T")
+
+
+class Baz(Generic[_T]):
+    def __get__(self, instance: Any, owner: Any) -> _T:
+        ...
+
+    def __set__(self, instance: Any, value: _T) -> None:
+        ...
+
+
+class Foo:
+    ...
+
+
+class Bar:
+    baz: Baz[list[Foo]]
+
+
+v10 = Bar()
+reveal_type(v10.baz, expected_text="list[Foo]")
+v10.baz = [Foo()]
+reveal_type(v10.baz, expected_text="list[Foo]")
+
+v11: List[Any] = [["hi", ["hi"], [[{}]]]]
+reveal_type(v11, expected_text="list[Any]")
+
+v12: List[Optional[int]] = [None] * 3
+reveal_type(v12, expected_text="list[int | None]")
+
+v13: List[Optional[str]] = ["3", None] * 2
+reveal_type(v13, expected_text="list[str | None]")
+
+x1 = 3
+v14: List[Optional[str]] = [None] * x1
+
+x2 = [1, 2, 3]
+v15: List[Optional[str]] = [None] * sum(x2)
+
+v16: Dict[str, List[Optional[str]]] = {n: [None] * len(n) for n in ["a", "aa", "aaa"]}
+
+
+ScalarKeysT = TypeVar("ScalarKeysT", bound=Literal["name", "country"])
+
+
+def func1(by: list[ScalarKeysT]) -> ScalarKeysT:
+    ...
+
+
+reveal_type(func1(["country"]), expected_type="Literal['country']")
+reveal_type(func1(["name"]), expected_type="Literal['name']")
+reveal_type(func1(["name", "country"]), expected_type="Literal['name', 'country']")
+
+# This should generate an error.
+func1(["id"])

package/src/tests/samples/listComprehension1.py

@@ -0,0 +1,45 @@
+# This sample tests type checking for list comprehensions.
+
+from typing import Any, Generator, Iterable, List, Literal
+
+a = [1, 2, 3, 4]
+
+
+def func1() -> Generator[int, None, None]:
+    b = (elem for elem in a)
+    return b
+
+
+def func2() -> List[int]:
+    c = [elem for elem in a]
+    return c
+
+
+def func3() -> List[str]:
+    c = [elem for elem in a]
+
+    # This should generate an error because
+    # c is a List[int], which doesn't match
+    # the declared return type.
+    return c
+
+
+def generate():
+    for i in range(2):
+        yield i
+
+
+# Verify that generate returns a Generator.
+s = generate()
+s.close()
+
+# verify that literals are handled correctly.
+FooOrBar = Literal["foo", "bar"]
+
+
+def to_list(values: Iterable[FooOrBar]) -> List[FooOrBar]:
+    return [value for value in values]
+
+x = 3
+# This should generate a syntax error.
+[x for in range(3)]

package/src/tests/samples/listComprehension2.py

@@ -0,0 +1,17 @@
+# This sample tests interleaved for and if clauses in a list comprehension.
+
+# pyright: strict
+
+from typing import Union, List, Tuple
+
+m1: List[Union[Tuple[int, int], None]] = []
+
+a = [
+    y + z + x[0]
+    for x in m1
+    if x is not None
+    for y in x
+    if y is not None
+    for z in [1, None, 3]
+    if z is not None
+]

package/src/tests/samples/listComprehension3.py

@@ -0,0 +1,12 @@
+# This sample tests type inference for list comprehensions,
+# including list target expressions in for statements.
+
+
+def foo() -> list[str]:
+    pairs = [s.split(":") if ":" in s else [s, "null"] for s in ["foo:bar", "baz"]]
+    foo = [p[0] for p in pairs]
+    if foo:
+        return foo
+
+    bar = [a for [a, b] in pairs]
+    return bar

package/src/tests/samples/listComprehension4.py

@@ -0,0 +1,15 @@
+# This sample tests scoping rules for variables that are declared within
+# a list comprehension statement.
+
+a: str = "hello"
+
+# The statement "len(a)" should not generate an
+# error because "a" is not yet bound to the local
+# variable at the time it is executed. Instead, it
+# has the str type of the "a" in the outer scope.
+b = [a for a in [len(a)]]
+
+# This assignment should succeed because "a" at this
+# point should have the type of "a" in the outer scope,
+# not the int type from the list comprehension.
+c: str = a

package/src/tests/samples/listComprehension5.py

@@ -0,0 +1,20 @@
+# This sample tests the type inference of list comprehensions
+# that result in AsyncGenerator types.
+
+import asyncio
+
+
+async def do_iter():
+    for i in range(10):
+        yield i
+        await asyncio.sleep(0.1)
+
+
+async def doit():
+    as_list = (i + 1 async for i in do_iter())
+
+    async for i in as_list:
+        print(i)
+
+
+asyncio.run(doit())

package/src/tests/samples/listComprehension6.py

@@ -0,0 +1,14 @@
+# This sample tests parsing of list comprehensions with
+# various syntax errors.
+
+# This should generate an error.
+(*i for i in [])
+
+# This should generate an error.
+[*i for i in []]
+
+# This should generate an error.
+{*d for d in []}
+
+# This should generate an error.
+{**d for d in []}

package/src/tests/samples/listComprehension7.py

@@ -0,0 +1,15 @@
+# This sample validates that list comprehensions within a class
+# body do not reference class-scoped variables within the
+# comprehension unless they are within the initial iterator expression.
+
+outer_var = [1, 2]
+
+
+class A:
+    var1 = [1, 2]
+    var2 = {x for x in var1}
+
+    # This should generate an error.
+    var3 = {var1[0] for x in var1}
+
+    var4 = {outer_var[0] for x in outer_var}

package/src/tests/samples/listComprehension8.py

@@ -0,0 +1,15 @@
+# This sample tests the evaluation of a list comprehension where
+# there are interdependencies between some of the variables.
+
+# pyright: strict
+
+
+class Foo:
+    input: str
+    output: str
+
+
+def minify1(foo: Foo):
+    foo.output = "".join(
+        stripped for line in foo.input.splitlines() if (stripped := line.strip())
+    )

package/src/tests/samples/literalString1.py

@@ -0,0 +1,43 @@
+# This sample tests the evaluation of LiteralString as described
+# in PEP 675.
+
+from typing_extensions import Literal, LiteralString
+
+
+def func1(a: str, b: bytes, c: Literal["a"], d: Literal["a", "b"], e: Literal["a", 1]):
+    # This should generate an error.
+    v1: LiteralString = a
+
+    # This should generate an error.
+    v2: LiteralString = b
+
+    # This should generate an error.
+    v3: LiteralString = b""
+
+    v4: LiteralString = "Hello!"
+
+    v5: LiteralString = "Hello " + "Bob"
+
+    # This should generate an error.
+    v6: LiteralString = f"{a}"
+
+    # This should generate an error.
+    v7: LiteralString[int]
+
+    v8: LiteralString = c
+
+    v9: LiteralString = d
+
+    # This should generate an error.
+    v10: LiteralString = e
+
+
+def func2(a: str):
+    ...
+
+
+def func3(a: LiteralString):
+    func2(a)
+    a.lower()
+
+    _ = a + "hi" + a.capitalize()