@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/optional1.py

@@ -0,0 +1,77 @@
+# This sample tests use of "Optional" types.
+
+from typing import Any, Optional
+
+
+class Foo:
+    def __init__(self):
+        self.value = 3
+
+    def do_stuff(self):
+        pass
+
+    def __enter__(self):
+        return 3
+
+    def __exit__(
+        self,
+        t: Optional[type] = None,
+        exc: Optional[BaseException] = None,
+        tb: Optional[Any] = None,
+    ) -> bool:
+        return True
+
+
+a = None
+if 1:
+    a = Foo()
+
+# If "reportOptionalMemberAccess" is enabled,
+# this should generate an error.
+a.value = 3
+
+
+def foo():
+    pass
+
+
+b = None
+if 1:
+    b = foo
+
+# If "reportOptionalCall" is enabled,
+# this should generate an error.
+b()
+
+
+c = None
+if 1:
+    c = [3, 4, 5]
+
+# If "reportOptionalSubscript" is enabled,
+# this should generate an error.
+c[2]
+
+
+# If "reportOptionalIterable" is enabled,
+# this should generate an error.
+for val in c:
+    pass
+
+# If "reportOptionalContextManager" is enabled,
+# this should generate an error.
+cm = None
+if 1:
+    cm = Foo()
+with cm as val:
+    pass
+
+# If "reportOptionalOperand" is enabled,
+# this should generate 3 errors.
+e = None
+if 1:
+    e = 4
+
+v1 = e + 4
+v2 = e < 5
+v3 = not e

package/src/tests/samples/optional2.py

@@ -0,0 +1,23 @@
+# This sample verifies that the reportOptionalOperand diagnostic
+# isn't generated when the RHS operand accepts None.
+
+from typing import Optional
+
+
+class Cmp:
+    def __eq__(self, other: "Optional[Cmp]") -> bool:
+        ...
+
+    def __lt__(self, other: "Optional[Cmp]") -> bool:
+        ...
+
+    def __gt__(self, other: "Cmp") -> bool:
+        ...
+
+
+def valid(value: Optional[Cmp], needed: Cmp):
+    x = value >= needed
+    y = value == needed
+
+    # This should generate an error if reportOptionalOperand is enabled.
+    z = value <= needed

package/src/tests/samples/overload1.py

@@ -0,0 +1,50 @@
+# This sample tests the type checker's handling of the overload decorator.
+
+from typing import overload, Optional
+from datetime import datetime, timezone, timedelta
+
+
+@overload
+def from_json_timestamp(ts: int) -> datetime:
+    ...
+
+
+@overload
+def from_json_timestamp(ts: None) -> None:
+    ...
+
+
+def from_json_timestamp(ts: Optional[int]) -> Optional[datetime]:
+    return (
+        None
+        if ts is None
+        else (datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(milliseconds=ts))
+    )
+
+
+result1: datetime = from_json_timestamp(2418049)
+
+# This should generate an error
+result2: datetime = from_json_timestamp(None)
+
+result3: None = from_json_timestamp(None)
+
+# This should generate an error
+result4: None = from_json_timestamp(2345)
+
+
+@overload
+def func1(x: int) -> int:
+    ...
+
+
+@overload
+def func1(x: float) -> float:
+    ...
+
+
+def func1(x):
+    return x
+
+
+reveal_type(func1(abs(0.0)), expected_text="float")

package/src/tests/samples/overload10.py

@@ -0,0 +1,48 @@
+# This sample tests an overload that provides a signature for
+# a *args parameter.
+
+
+from typing import Iterable, Tuple, TypeVar, overload
+
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+
+
+@overload
+def func1(__iter1: Iterable[_T1]) -> Tuple[_T1]:
+    ...
+
+
+@overload
+def func1(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Tuple[_T1, _T2]:
+    ...
+
+
+# This should generate an error because this overload overlaps
+# with the first one and returns a different type.
+@overload
+def func1(*iterables: Iterable[_T1]) -> Tuple[_T1, ...]:
+    ...
+
+
+def func1(*iterables: Iterable[_T1]) -> Tuple[_T1, ...]:
+    ...
+
+
+def func2(x: Iterable[int]):
+    v1 = func1(x)
+    reveal_type(v1, expected_text="Tuple[int]")
+
+    v2 = func1(x, x)
+    reveal_type(v2, expected_text="Tuple[int, int]")
+
+    y = [x, x, x, x]
+
+    v3 = func1(*y)
+    reveal_type(v3, expected_text="Tuple[int, ...]")
+
+    z = (x, x)
+
+    v4 = func1(*z)
+    reveal_type(v4, expected_text="Tuple[int, int]")

package/src/tests/samples/overload2.py

@@ -0,0 +1,37 @@
+# This sample verifies that overloads work in
+# conjunction with async methods.
+
+from typing import Union, overload
+
+
+@overload
+async def func(x: int) -> int:
+    ...
+
+
+@overload
+async def func(x: str) -> str:
+    ...
+
+
+async def func(x) -> Union[int, str]:
+    if isinstance(x, int):
+        return 32
+    else:
+        return "that"
+
+
+def requires_str(a: str):
+    pass
+
+
+def requires_int(a: int):
+    pass
+
+
+async def test_function():
+    should_be_str = await func("2")
+    requires_str(should_be_str)
+
+    should_be_int = await func(2)
+    requires_int(should_be_int)

package/src/tests/samples/overload3.py

@@ -0,0 +1,29 @@
+# This sample verifies that the type checker doesn't use the
+# final function that omits the @overload decorator when matching
+# a caller against an overloaded function.
+
+from typing import Union, TypeVar, overload, Tuple, Optional
+
+T = TypeVar("T")
+
+
+@overload
+def mouse_event(x1: int, y1: int) -> int:
+    ...
+
+
+@overload
+def mouse_event(x1: int, y1: int, x2: int, y2: int) -> Tuple[int, int]:
+    ...
+
+
+def mouse_event(
+    x1: int, y1: int, x2: Optional[int] = None, y2: Optional[int] = None
+) -> Union[int, Tuple[int, int]]:
+    return 1
+
+
+# This should generate an error because it doesn't match either
+# of the @overload versions, even though it does match the
+# version of the function that omits the @overload.
+t = mouse_event(1, 2, 3)

package/src/tests/samples/overload4.py

@@ -0,0 +1,46 @@
+# This sample verifies that a lone overload is reported
+# as an error.
+
+from typing import Protocol, overload
+
+
+# This should generate an error because there is only one overload.
+@overload
+def foo1() -> None:
+    ...
+
+
+def foo1() -> None:
+    ...
+
+
+# This should generate an error because there is only one overload.
+@overload
+def foo2(a: int) -> None:
+    ...
+
+
+def foo2(a: int) -> None:
+    pass
+
+
+class ClassA:
+    # This should generate an error because there is no implementation.
+    @overload
+    def foo3(self) -> None:
+        ...
+
+    @overload
+    def foo3(self, a: int) -> None:
+        ...
+
+
+class ClassB(Protocol):
+    # An implementation should not be required in a protocol class.
+    @overload
+    def foo(self) -> None:
+        ...
+
+    @overload
+    def foo(self, name: str) -> str:
+        ...

package/src/tests/samples/overload5.py

@@ -0,0 +1,333 @@
+# This sample tests the type checker's detection of overlapping
+# overload declarations.
+
+from typing import (
+    Any,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+
+@overload
+def func1(a: float, b: Optional[float], c: Optional[bool] = None) -> int:
+    ...
+
+
+# This should generate an error because the overload is obscured.
+@overload
+def func1(a: int, b: int) -> int:
+    ...
+
+
+@overload
+def func1(a: int, b: int, *, named: int = 3) -> int:
+    ...
+
+
+# This should generate an error because the overload is obscured.
+@overload
+def func1(a: int, b: int, *, named: int) -> int:
+    ...
+
+
+@overload
+def func1(a: complex, b: int) -> int:
+    ...
+
+
+def func1(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+@overload
+def func2(a: int, b: Any) -> int:
+    """Overload"""
+
+
+# This should generate an error because the overload is obscured.
+@overload
+def func2(a: int, b: int) -> int:
+    """Overload"""
+
+
+def func2(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+@overload
+def func3(a: int, b: int) -> int:
+    ...
+
+
+@overload
+def func3(a: int, b: int, **c: Any) -> int:
+    ...
+
+
+@overload
+def func3(a: int, b: Any) -> int:
+    ...
+
+
+def func3(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+@overload
+def func4(a: int, *, c: int, b: int) -> int:
+    ...
+
+
+# This should generate an error because the overload is obscured.
+@overload
+def func4(a: int, *, b: int, c: int) -> int:
+    ...
+
+
+def func4(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+# This should generate an error because the overload is overlapping
+# in an unsafe way (i.e. returns an incompatible type).
+@overload
+def func5(a: int, b: int) -> int:
+    ...
+
+
+@overload
+def func5(a: float, b: float = 3.4, *c: int, d: float = 4.5) -> str:
+    ...
+
+
+def func5(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+
+
+class GenericClass(Generic[_T1, _T2]):
+    @overload
+    def method1(self, a: _T1, b: Tuple[_T2, ...]) -> int:
+        ...
+
+    @overload
+    def method1(self, a: _T1, b: Tuple[Any, ...]) -> int:
+        ...
+
+    def method1(self, *args: Any, **kwargs: Any) -> Any:
+        ...
+
+    @overload
+    def method2(self, a: _T2, b: int) -> int:
+        ...
+
+    @overload
+    def method2(self, a: _T1, b: _T2) -> int:
+        ...
+
+    def method2(self, *args: Any, **kwargs: Any) -> Any:
+        pass
+
+
+class Parent:
+    ...
+
+
+class Child(Parent):
+    ...
+
+
+# Test 1: Literal subtype
+@overload
+def func10(x: Literal[3]) -> int:
+    ...
+
+
+@overload
+def func10(x: int) -> str:
+    ...
+
+
+def func10(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+# Test 2: Subclass subtype
+@overload
+def func11(x: Child) -> str:
+    ...
+
+
+@overload
+def func11(x: Parent) -> int:
+    ...
+
+
+def func11(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+# Test 3: Implicit subtype
+@overload
+def func12(x: int) -> str:
+    ...
+
+
+@overload
+def func12(x: float) -> int:
+    ...
+
+
+def func12(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+# Test 4: Union subtype
+@overload
+def func13(x: int) -> str:
+    ...
+
+
+@overload
+def func13(x: Union[int, str]) -> int:
+    ...
+
+
+def func13(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+# Test 5: non-matching keyword argument
+@overload
+def func14(x: int, *, cls: str, **kwargs: Any) -> int:
+    ...
+
+
+@overload
+def func14(x: int, **kwargs: Any) -> str:
+    ...
+
+
+def func14(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+# Test 6: non-matching keyword argument (shouldn't generate error)
+@overload
+def func15(cls: str, **kwargs: Any) -> int:
+    ...
+
+
+@overload
+def func15(**kwargs: Any) -> str:
+    ...
+
+
+def func15(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+@overload
+def func16(var: None) -> List[Any]:
+    ...
+
+
+@overload
+def func16(var: _T1) -> List[_T1]:
+    ...
+
+
+def func16(var: Union[_T1, None]) -> List[_T1] | List[Any]:
+    ...
+
+
+@overload
+def func17(a: int, b: List[int]) -> int:
+    ...
+
+
+@overload
+def func17(a: int, b: List[_T1]) -> _T1:
+    ...
+
+
+def func17(*args: Any, **kwargs: Any) -> Any:
+    pass
+
+
+class ClassA(Generic[_T1]):
+    @overload
+    def __call__(self, f: _T1) -> _T1:
+        ...
+
+    @overload
+    def __call__(self, f: _T1 | None) -> _T1:
+        ...
+
+    def __call__(self, f: _T1 | None) -> _T1:
+        ...
+
+
+class ClassB:
+    @overload
+    def __call__(self, f: _T1) -> _T1:
+        ...
+
+    # This should generate an error because the overload is overlapped.
+    @overload
+    def __call__(self, f: _T1 | None) -> _T1:
+        ...
+
+    def __call__(self, f: _T1 | None) -> _T1:
+        ...
+
+
+class ClassC:
+    @overload
+    def method1(self, x: Type[Any]) -> bool:
+        ...
+
+    @overload
+    def method1(self, x: Any) -> str | bool:
+        ...
+
+    def method1(self, x: Any) -> Any:
+        ...
+
+
+class ClassD:
+    @overload
+    def method1(self, x: type) -> bool:
+        ...
+
+    @overload
+    def method1(self, x: Any) -> str | bool:
+        ...
+
+    def method1(self, x: Any) -> Any:
+        ...
+
+
+@overload
+def func18(s: Sequence[_T1], extra: Literal[False]) -> list[_T1]: ...
+
+@overload
+def func18(s: Sequence[_T1], extra: Literal[True]) -> list[_T1] | tuple[_T1]: ...
+
+@overload
+def func18(s: Sequence[_T1], extra: bool) -> list[_T1] | tuple[_T1]: ...
+
+def func18(s: Sequence[_T1], extra: bool) -> list[_T1] | tuple[_T1]:
+    ...
+

package/src/tests/samples/overload6.py

@@ -0,0 +1,64 @@
+# This sample tests the handling of type checking of overloaded methods
+# and functions. In particular, it handles the case where the destination
+# is an overload and the source is either another overload or a function
+# type. This case is important for protocol matching if the protocol
+# includes an overloaded method.
+
+from fractions import Fraction
+from typing import Any, Optional, Protocol, TypeVar, Union, overload
+
+v1 = round(Fraction(1))
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+_T = TypeVar("_T")
+
+
+class SupportsRound1(Protocol[_T_co]):
+    @overload
+    def __round__(self) -> int:
+        ...
+
+    @overload
+    def __round__(self, ndigits: int) -> _T_co:
+        ...
+
+    # This should generate an error because the return type isn't compatible.
+    def __round__(self, ndigits: int = 0) -> _T_co:
+        ...
+
+
+class Proto1:
+    def __round__(self, ndigits: int) -> "Fraction":
+        ...
+
+
+def round1(number: SupportsRound1[Any]) -> int:
+    ...
+
+
+v_proto1 = Proto1()
+
+# This should generate an error
+v_round1 = round1(v_proto1)
+
+
+class Proto2:
+    @overload
+    def __round__(self, ndigits: int) -> "Fraction":
+        ...
+
+    @overload
+    def __round__(self, ndigits: None = ...) -> int:
+        ...
+
+    def __round__(self, ndigits: Optional[int] = None) -> Union["Fraction", int]:
+        ...
+
+
+def round2(number: SupportsRound1[Any]) -> int:
+    ...
+
+
+v_proto2 = Proto2()
+v_round2 = round2(v_proto2)