@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/assignment1.py

@@ -0,0 +1,58 @@
+# This sample tests the type checker's handling of
+# member assignments.
+
+
+class Foo:
+    def __init__(self):
+        self.string_list: list[str] = []
+
+    def do_something(self, num: int) -> str:
+        return ""
+
+
+a = Foo()
+
+a.string_list = ["yep"]
+
+# This should generate an error because of a type mismatch.
+a.string_list = "bbb"
+
+# This should generate an error because of a type mismatch.
+a.string_list = {}
+
+# This should generate an error because of a type mismatch.
+a.string_list = [1]
+
+# This should generate an error because there is no member
+# called string_list2 defined.
+a.string_list2 = 4
+
+
+def patch1(num: int) -> str:
+    return ""
+
+
+def patch2(self, num: int) -> str:
+    return ""
+
+
+a.do_something = lambda num: "hello"
+a.do_something = patch1
+
+# This should generate an error because of a param count mismatch
+a.do_something = lambda: "hello"
+
+# This should generate an error because of a return type mismatch
+a.do_something = lambda x: 1
+
+
+Foo.do_something = patch2
+
+# This should generate an error because of a param count mismatch
+Foo.do_something = patch1
+
+
+class Class1:
+    # This should generate an error because assignment expressions
+    # can't be used within a class.
+    [(j := i) for i in range(5)]

package/src/tests/samples/assignment10.py

@@ -0,0 +1,14 @@
+# This sample tests some cases where types are narrowed on assignment.
+
+
+class A:
+    instance: "A" | None
+
+    def __init__(self) -> None:
+        self.foo: bool
+
+    @classmethod
+    def method1(cls) -> bool:
+        if cls.instance is None:
+            cls.instance = cls()
+        return cls.instance.foo

package/src/tests/samples/assignment2.py

@@ -0,0 +1,40 @@
+# This sample tests assignments to indexed expressions
+# where the base is a specialized object.
+
+from typing import List, Dict, Union
+
+
+v1: List[int] = [1, 2, 3, 4, 5]
+# This should generate an error because
+# the assigned type is wrong.
+v1[0] = "a"
+
+v2: Dict[int, str] = {1: "str"}
+# This should generate an error because
+# the assigned type is wrong.
+v2[1] = 123
+
+v3: List[Union[int, str]] = ["a"]
+v3[0] = 3
+reveal_type(v3[0], expected_text="Literal[3]")
+
+
+v4: Dict[str, Union[int, str]] = {}
+v4["aaa"] = 3
+v4["bbb"] = "bbb"
+reveal_type(v4["aaa"], expected_text="Literal[3]")
+reveal_type(v4["bbb"], expected_text="Literal['bbb']")
+reveal_type(v4["ccc"], expected_text="int | str")
+
+
+class Asymmetric:
+    def __setitem__(self, i: int, value: object) -> None:
+        ...
+
+    def __getitem__(self, i: int) -> int:
+        ...
+
+
+v5 = Asymmetric()
+v5[0] = 3
+reveal_type(v5[0], expected_text="int")

package/src/tests/samples/assignment3.py

@@ -0,0 +1,46 @@
+# This sample tests various assignment scenarios where
+# there is an expected type, so bidirectional type
+# inference is used.
+
+from typing import Callable, Dict, Protocol, Tuple
+
+f1: Callable[[int, int], int] = lambda a, b: a + b
+
+# This should generate an error because x should be
+# determined to be an "int", so "len(x)" is invalid.
+map(lambda x: len(x), [1, 2, 3])
+
+
+def must_be_int(val: int):
+    return val
+
+
+d1: Dict[str, Tuple[int, Callable[[int], int]]] = {
+    "hello": (3, lambda x: must_be_int(x))
+}
+
+d2: Dict[str, Tuple[int, Callable[[int], int]]] = {
+    # This should generate an error because the key is not a str.
+    3: (3, lambda x: must_be_int(x))
+}
+
+d3: Dict[str, Tuple[int, Callable[[int], int]]] = {
+    # This should generate an error because the first element
+    # of the tuple is not the correct type.
+    "3": (3.0, lambda x: must_be_int(x))
+}
+
+d4: Dict[str, Tuple[int, Callable[[int], int]]] = {
+    # This should generate an error because the lambda
+    # type doesn't match.
+    "3": (3, lambda _: 3.4)
+}
+
+
+class Adder(Protocol):
+    def __call__(self, x: int, y: Dict[str, int]) -> int:
+        ...
+
+
+v1: Adder = lambda x, y: x + y["hi"]
+reveal_type(v1, expected_text="(x: int, y: Dict[str, int]) -> int")

package/src/tests/samples/assignment4.py

@@ -0,0 +1,20 @@
+# This sample tests various assignment scenarios where
+# there is an expected type, so bidirectional type
+# inference is used.
+
+# pyright: strict
+
+from typing import Dict, Callable, Sequence, Tuple
+
+AAA = float
+BBB = int
+CCC = str
+DDD = str
+AAATuple = Tuple[AAA, BBB, Callable[[Sequence[int], AAA], Sequence[float]]]
+
+
+def foo():
+    var1: Dict[str, Tuple[AAA, BBB, CCC, DDD]] = {}
+    var2: Dict[str, AAATuple] = {}
+    for k, (var3, var4, _, _) in var1.items():
+        var2[k] = (var3, var4, lambda var5, var6: [v * var6 for v in var5])

package/src/tests/samples/assignment5.py

@@ -0,0 +1,16 @@
+# This sample tests the handling of tuple assignments
+# where the order of assignment within the tuple is important.
+
+from typing import Optional
+
+
+class Node:
+    key: str
+    next: Optional["Node"] = None
+
+
+node = Node()
+
+# This should analyze fine because node.next should be assigned
+# None before node is assigned None.
+node.next, node = None, None

package/src/tests/samples/assignment6.py

@@ -0,0 +1,25 @@
+# This sample tests that the type checker handles the case
+# where a symbol within a class scope is assigned an expression
+# that includes the same symbol, but that same symbol is defined
+# in an outer scope.
+
+a = 0
+b = 1
+c = 4
+
+
+class MyClass:
+    # This should not generate an error because
+    # the RHS of the assignment refers to a different
+    # "a", declared in an outer scope.
+    a = a
+
+    # Same with "b" here.
+    (b, a) = (b, 3)
+
+    # Same with "c" here.
+    [c] = [c]
+
+    # This should generate an error because "d" is
+    # not declared in the outer scope.
+    e = d

package/src/tests/samples/assignment7.py

@@ -0,0 +1,13 @@
+# This sample tests a particularly difficult set of dependent
+# assignments that involve tuple packing and unpacking.
+
+# pyright: strict
+
+v1 = ""
+v3 = ""
+
+v2, _ = v1, v3
+v4 = v2
+for _ in range(1):
+    v1 = v4
+    v2, v3 = v1, ""

package/src/tests/samples/assignment8.py

@@ -0,0 +1,40 @@
+# This sample ensures that a variable of type "object" can be
+# assigned any other type.
+
+import os
+from typing import Any, Optional, TypeVar, overload
+
+
+class Foo:
+    @overload
+    def bar(self, obj: None) -> object:
+        ...
+
+    @overload
+    def bar(self, obj: object) -> Any:
+        ...
+
+    def bar(self, obj: Optional[object]) -> Any:
+        pass
+
+    @staticmethod
+    def baz():
+        return 3
+
+
+_T = TypeVar("_T")
+
+my_obj: object
+
+my_obj = None
+my_obj = os
+my_obj = Foo
+my_obj = Foo()
+my_obj = Foo.bar
+my_obj = Foo.baz
+my_obj = ()
+my_obj = lambda x: x
+my_obj = _T
+
+# This should generate an error because a is unbound.
+my_obj = a

package/src/tests/samples/assignment9.py

@@ -0,0 +1,25 @@
+# This sample tests assignment when the types are invariant and the
+# source or destination are unions that contains subtypes which are 
+# subclasses of each other.
+
+from datetime import datetime
+from typing import List, Union
+
+
+class FloatSubclass(float):
+    pass
+
+
+float_list: List[float] = [1.0, 2.0]
+
+v1: List[Union[float, FloatSubclass]] = float_list
+
+v2: List[Union[int, float]] = float_list
+
+# This should generate an error.
+v3: List[Union[int, float, datetime]] = float_list
+
+
+v4: List[FloatSubclass | float] = []
+v5: List[float] = v4
+

package/src/tests/samples/assignmentExpr1.py

@@ -0,0 +1,23 @@
+# This sample tests the Python 3.8 assignment expressions.
+
+# pyright: reportUnusedExpression=false
+
+def func1():
+    b = 'a'
+    d = 'b'
+
+    a = (b := 3)
+
+    # This should generate an error because the
+    # item to the left of an assignment expression
+    # must be a name.
+    a + 3 := 3
+
+    # This should generate an error because parens
+    # are required in this case.
+    c = d := 3
+
+# This should generate an error because parens are required in this case.
+val if val := 1 + 2 else None
+
+val2 if (val2 := 1 + 2) else None

package/src/tests/samples/assignmentExpr2.py

@@ -0,0 +1,49 @@
+# This sample tests the Python 3.8 assignment expressions.
+
+# pyright: reportUnusedExpression=false
+
+import re
+
+def foo(x: float):
+    ...
+
+def pep572_examples():
+    # Handle a matched regex
+    if (match := re.search('123', '252')) is not None:
+        print(match)
+    print(match)
+
+    # A loop that can't be trivially rewritten using 2-arg iter()
+    file = open('hello')
+    while chunk := file.read(8192):
+        print(chunk)
+    print(chunk)
+
+    # Reuse a value that's expensive to compute
+    def f(x: float):
+        return x
+    mylist = [y := f(25), y**2, y**3]
+
+    # Share a subexpression between a comprehension filter clause and its output
+    data = [1, 2, 3]
+    filtered_data = [y for x in data if (y := f(x)) is not None]
+    print(filtered_data)
+    
+    # This should generate an error.
+    y := f(25)  # INVALID
+    (y := f(25))  # Valid, though not recommended
+
+    y1 = 1
+
+    # This should generate an error.
+    y0 = y1 := f(25)  # INVALID
+    y0 = (y1 := f(25))  # Valid, though discouraged
+
+    # This should generate an error.
+    foo(x = y := f(25))  # INVALID
+    foo(x=(y := f(25)))  # Valid, though probably confusing
+
+    # This should generate an error.
+    [y for x in [0, 1] if y := x - 1]
+
+    [y for x in [0, 1] if (y := x - 1)]

package/src/tests/samples/assignmentExpr3.py

@@ -0,0 +1,27 @@
+# This sample tests the Python 3.8 assignment expressions.
+
+import re
+
+def foo1(x: float):
+    ...
+
+p = 3
+
+# This should generate an error.
+def foo2(answer = p := 42):  # INVALID
+    ...
+
+def foo3(answer=(p := 42)):  # Valid, though not great style
+    ...
+
+default_value: int = 3
+
+# This should generate an error.
+def foo4(answer: p := default_value = 5):  # INVALID
+    ...
+
+# This should generate an error.
+(lambda: x := 1) # INVALID
+lambda: (x := 1) # Valid, but unlikely to be useful
+(x := lambda: 1) # Valid
+lambda line: (m := re.match('pattern', 'line')) and m.group(1) # Valid

package/src/tests/samples/assignmentExpr4.py

@@ -0,0 +1,49 @@
+# This sample tests error detection for certain cases that
+# are explicitly disallowed by PEP 572 for assignment expressions
+# when used in context of a list comprehension.
+
+pairs = []
+stuff = []
+
+# These should generate an error because assignment
+# expressions aren't allowed within an iterator expression
+# in a "for" clause of a list comprehension.
+[x for x, y in (pairs2 := pairs) if x % 2 == 0]
+[x for x, y in ([1, 2, 3, pairs2 := pairs]) if x % 2 == 0]
+{x: y for x, y in (pairs2 := pairs) if x % 2 == 0}
+{x for x, y in (pairs2 := pairs) if x % 2 == 0}
+foo = (x for x, y in ([1, 2, 3, pairs2 := pairs]) if x % 2 == 0)
+
+# This should generate an error because 'j' is used as a
+# "for target" and the target of an assignment expression.
+[[(j := j) for i in range(5)] for j in range(5)]
+[i := 0 for i, j in stuff]
+[i + 1 for i in (i := stuff)]
+
+[False and (i := 0) for i, j in stuff]
+[i for i, j in stuff if True or (j := 1)]
+
+# These should generate an error because assignment
+# expressions aren't allowed within an iterator expression
+# in a "for" clause of a list comprehension.
+[i + 1 for i in (j := stuff)]
+[i + 1 for i in range(2) for j in (k := stuff)]
+[i + 1 for i in [j for j in (k := stuff)]]
+[i + 1 for i in (lambda: (j := stuff))()]
+
+
+class Example:
+    # This should generate an error because the containing
+    # scope for the list comprehension is a class.
+    [(j := i) for i in range(5)]
+
+    x = ((y := 1), (z := 2))
+
+
+Example.x
+Example.y
+Example.z
+
+# This should generate an error because 'j' is used as a
+# "for target" and the target of an assignment expression.
+[i for i in [1, 2] if True or (j := 1) for j in range(10)]

package/src/tests/samples/assignmentExpr5.py

@@ -0,0 +1,15 @@
+# This sample tests the scoping rules for assignment expressions
+# within a list comprehension.
+
+from typing import Tuple
+
+
+def foo() -> Tuple[str, int]:
+    a = 3
+    y = 4
+    b = [(a := x) for x in ["1", "2"] for y in ["1", "2"]]
+
+    # The type of "y" should be int because the "y" within
+    # the list comprehension doesn't leak outside. On the
+    # other hand, "a" does leak outside the list comprehension.
+    return (a, y)

package/src/tests/samples/assignmentExpr6.py

@@ -0,0 +1,10 @@
+# This sample tests that type guards work correctly
+# with the walrus operator.
+
+import re
+
+
+def foo(s: str) -> str:
+    if m := re.fullmatch("(test).+", s):
+        return m.group(1)
+    return "oops"

package/src/tests/samples/assignmentExpr7.py

@@ -0,0 +1,13 @@
+# This sample tests assignment expressions used within
+# arguments
+
+import collections
+
+
+class NearestKeyDict(collections.UserDict):
+    def _keytransform(self, key):
+        a = len(candidate_keys := [k for k in sorted(self.data) if k >= key])
+
+        # This should generate an error because walrus operators
+        # are not allowed with named arguments.
+        b = list(iterable = candidate_keys := [k for k in sorted(self.data) if k >= key])

package/src/tests/samples/assignmentExpr8.py

@@ -0,0 +1,11 @@
+# This sample checks that parsing for the assignment expression
+# operator is using the correct precedence. It should be parsing
+# the RHS as a "test expression" which allows for ternary
+# expressions.
+
+result = None
+
+if items := 3 if result else None:
+    pass
+
+print(items)

package/src/tests/samples/assignmentExpr9.py

@@ -0,0 +1,28 @@
+# This sample tests the case where an assignment expression target
+# is found within a function decorator or a function default value expression.
+
+from typing import Any, Callable, List, TypeVar
+
+
+_T = TypeVar("_T")
+
+
+def decorator(*args: Any, **kwargs: Any) -> Callable[[_T], _T]:
+    ...
+
+
+@decorator(
+    [
+        walrus_target_1
+        for combination in [[1]]
+        if None not in (walrus_target_1 := set(combination))
+    ],
+)
+def decorated(
+    x: List[str] = [x for x in ["a", "b"] if x in (walrus_target_2 := ["a", "b"])]
+):
+    pass
+
+
+reveal_type(walrus_target_1, expected_text="set[int]")
+reveal_type(walrus_target_2, expected_text="list[str]")

package/src/tests/samples/async1.py

@@ -0,0 +1,49 @@
+# This sample validates that "async" is flagged as an error when
+# used in inappropriate locations.
+
+from contextlib import AsyncExitStack
+
+
+async def b():
+    for i in range(5):
+        yield i
+
+
+cm = AsyncExitStack()
+
+
+def func1():
+    # This should generate an error because
+    # "async" cannot be used in a non-async function.
+    async for x in b():
+        print("")
+
+    # This is allowed because it's in a generator.
+    y = (x async for x in b())
+
+    # This should generate an error because
+    # "async" cannot be used in a non-async function.
+    async with cm:
+        pass
+
+    # This should generate an error because
+    # "async" cannot be used in a non-async function.
+    return [x async for x in b()]
+
+
+# This should generate an error because
+# "async" cannot be used in a non-async function.
+async for x in b():
+    print("")
+
+# This is allowed because it's in a generator.
+y = (x async for x in b())
+
+# This should generate an error because
+# "async" cannot be used in a non-async function.
+async with cm:
+    pass
+
+# This should generate an error because
+# "async" cannot be used in a non-async function.
+[x async for x in b()]

package/src/tests/samples/augmentedAssignment1.py

@@ -0,0 +1,62 @@
+# This sample tests the type checker's handling of
+# augmented assignments (combining a binary operator
+# with an assignment).
+
+
+a = 1
+b = 3.4
+
+a += b
+reveal_type(a, expected_text="float")
+
+a -= b
+reveal_type(a, expected_text="float")
+
+a *= b
+reveal_type(a, expected_text="float")
+
+a /= b
+reveal_type(a, expected_text="float")
+
+a //= b
+reveal_type(a, expected_text="float")
+
+a %= b
+reveal_type(a, expected_text="float")
+
+a **= b
+reveal_type(a, expected_text="Any")
+
+a = 1
+
+# This should generate an error because
+# matrix multiply isn't supported by int.
+a @= b
+
+a |= b
+a &= b
+a ^= b
+a <<= b
+a >>= b
+
+
+list1 = [1, 2, 3]
+list1 += [4]
+
+# This should generate an error
+list1 += 4
+
+# This should generate an error
+list2 = [1]
+list2 *= 4
+
+# This should generate an error
+list2 *= [4]
+
+
+# Test __iadd__ override in list class, which accepts
+# any iterator as an argument.
+bar = ("d",)
+foo = ["a", "b"]
+foo += ["c"]
+foo += bar

package/src/tests/samples/augmentedAssignment2.py

@@ -0,0 +1,23 @@
+# This sample tests expected diagnostics for augmented assignment
+# expressions.
+
+from typing import List, Optional
+
+
+def add_values(
+    values1: List[float] = [], values2: Optional[List[float]] = None
+) -> None:
+    values3 = None
+
+    # This should generate an error
+    values1 += values2
+
+    if values2 is not None:
+        values1 += values2
+
+    # This should generate an error
+    values1 -= values2
+
+    # This should generate an error
+    values1 += values3
+

package/src/tests/samples/augmentedAssignment3.py

@@ -0,0 +1,8 @@
+# This sample tests the case where an instance variable
+# is assigned using only augmented assignment expressions.
+
+
+class ClassA:
+    def a(self):
+        # This should generate an error.
+        self.val1 += 3