@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/src/tests/samples/assignment1.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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