@zzzen/pyright-internal 1.1.255 → 1.2.0-beta

package/src/tests/samples/overload7.py

@@ -1,376 +0,0 @@
-# This sample tests the verification that overload implementation signatures
-# are a superset of their associated overload signatures.
-
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Dict,
-    Generic,
-    Iterable,
-    List,
-    Literal,
-    NoReturn,
-    Optional,
-    ParamSpec,
-    Protocol,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-
-# This should generate an error because its input parameter
-# type is incompatible.
-@overload
-def func1(a: int) -> str:
-    ...
-
-
-# This should generate an error because its return parameter
-# type is incompatible.
-@overload
-def func1(a: str) -> int:
-    ...
-
-
-def func1(a: str) -> str:
-    return a
-
-
-# This should generate an error because the parameter "b" is missing
-# from the implementation.
-@overload
-def func2(a: int, b: str = ...) -> str:
-    ...
-
-
-@overload
-def func2(a: None) -> str:
-    ...
-
-
-def func2(a: Optional[int]) -> str:
-    ...
-
-
-@overload
-def func3(a: int, *, b: Literal["r"]) -> str:
-    ...
-
-
-@overload
-def func3(a: int, *, b: Literal["b"]) -> bytes:
-    ...
-
-
-def func3(*args: Any, **kwargs: Any) -> Any:
-    ...
-
-
-_T = TypeVar("_T")
-
-
-@overload
-def func4(a: None) -> None:
-    ...
-
-
-@overload
-def func4(a: List[_T]) -> _T:
-    ...
-
-
-def func4(a: Optional[List[_T]]) -> Optional[_T]:
-    ...
-
-
-class A:
-    @overload
-    def method4(self, a: None) -> None:
-        ...
-
-    @overload
-    def method4(self, a: List[_T]) -> _T:
-        ...
-
-    def method4(self, a: Optional[List[_T]]) -> Optional[_T]:
-        ...
-
-
-@overload
-def func5(a: List[_T]) -> _T:
-    ...
-
-
-@overload
-def func5(a: None) -> None:
-    ...
-
-
-# This should generate an error because List is not compatible with Dict.
-def func5(a: Optional[Dict[Any, Any]]) -> Optional[Any]:
-    ...
-
-
-@overload
-def func6(foo: int, /) -> int:
-    ...
-
-
-@overload
-def func6(bar: str, /) -> int:
-    ...
-
-
-def func6(p0: Union[int, str], /) -> int:
-    return 3
-
-
-_T1 = TypeVar("_T1")
-
-
-class ClassA(Generic[_T1]):
-    @overload
-    def method1(self: "ClassA[None]") -> None:
-        ...
-
-    @overload
-    def method1(self, value: _T1) -> None:
-        ...
-
-    def method1(self, value: Any = None) -> None:
-        ...
-
-
-class ClassB:
-    ...
-
-
-class ClassC:
-    ...
-
-
-_T2 = TypeVar("_T2", ClassB, ClassC)
-
-
-@overload
-def func7(cls: Type[ClassB], var: int) -> ClassB:
-    ...
-
-
-@overload
-def func7(cls: Type[ClassC], var: str) -> ClassC:
-    ...
-
-
-def func7(cls: Type[_T2], var: Union[int, str]) -> _T2:
-    return cls()
-
-
-_T3 = TypeVar("_T3")
-
-
-@overload
-def func8(foo: int) -> int:
-    ...
-
-
-@overload
-def func8(foo: _T3) -> Tuple[_T3]:
-    ...
-
-
-def func8(foo: Union[_T3, int]) -> Union[Tuple[_T3], int]:
-    ...
-
-
-class Foo:
-    ...
-
-
-_T4 = TypeVar("_T4", bound=Foo)
-
-
-@overload
-def func9() -> None:
-    ...
-
-
-@overload
-def func9(bar: _T4) -> _T4:
-    ...
-
-
-def func9(bar: Optional[_T4] = None) -> Optional[_T4]:
-    raise NotImplementedError
-
-
-_T5 = TypeVar("_T5", int, str)
-
-
-@overload
-def func10(option: Literal["a"], var: str) -> str:
-    ...
-
-
-@overload
-def func10(option: Literal["b"], var: int) -> str:
-    ...
-
-
-# This should generate an error.
-def func10(option: Literal["a", "b"], var: _T5) -> _T5:
-    ...
-
-
-class X:
-    ...
-
-
-_T6 = TypeVar("_T6", bound=Type[X])
-
-
-@overload
-def func11(var: _T6) -> _T6:
-    ...
-
-
-@overload
-def func11(var: int) -> int:
-    ...
-
-
-def func11(var: Union[_T6, int]) -> Union[_T6, int]:
-    ...
-
-
-_T7 = TypeVar("_T7")
-_T8 = TypeVar("_T8")
-_T9 = TypeVar("_T9")
-
-
-@overload
-def func12(func: Callable[[_T7], _T8], iterable: Iterable[_T7], /) -> Iterable[_T8]:
-    ...
-
-
-@overload
-def func12(
-    func: Callable[[_T7], _T8], iterable: Iterable[_T7], /, default_value: _T9
-) -> Iterable[_T8 | _T9]:
-    ...
-
-
-def func12(
-    func: Callable[[_T7], _T8],
-    iterable: Iterable[_T7],
-    /,
-    default_value: _T9 = None,
-) -> Iterable[_T8 | _T9]:
-    ...
-
-
-@overload
-def func13(x: int) -> NoReturn:
-    ...
-
-
-@overload
-def func13(x: str) -> str | NoReturn:
-    ...
-
-
-def func13(x: int | str) -> str:
-    ...
-
-
-_T14 = TypeVar("_T14")
-
-
-class Wrapper1(Generic[_T14]):
-    ...
-
-
-@overload
-def func14(target: Callable[..., Awaitable[_T14]]) -> Wrapper1[_T14]:
-    ...
-
-
-@overload
-def func14(target: Callable[..., _T14]) -> Wrapper1[_T14]:
-    ...
-
-
-def func14(
-    target: Callable[..., Awaitable[_T14]] | Callable[..., _T14]
-) -> Wrapper1[_T14]:
-    ...
-
-
-@overload
-def func15(client_id: str, client_secret: str, /) -> None:
-    ...
-
-
-@overload
-def func15(client_id: str, client_secret: str) -> None:
-    ...
-
-
-# This should generate an error because some of the keyword arguments are not present.
-def func15(*creds: str) -> None:
-    pass
-
-
-T1 = TypeVar("T1", covariant=True)
-T2 = TypeVar("T2", bound=Callable[..., Any])
-R = TypeVar("R")
-P = ParamSpec("P")
-
-
-class Builds(Protocol[T1]):
-    _target_: str
-
-
-class BuildsWithSig(Builds[T1], Protocol[T1, P]):
-    def __init__(self, *args: P.args, **kwds: P.kwargs):
-        ...
-
-
-class ClassD(Protocol):
-    @overload
-    def __call__(
-        self,
-        x: Callable[P, R],
-        *,
-        sig: Literal[True] = ...,
-    ) -> BuildsWithSig[Type[R], P]:
-        ...
-
-    @overload
-    def __call__(
-        self,
-        x: T2,
-        *,
-        sig: Literal[False] = ...,
-    ) -> Builds[Type[T2]]:
-        ...
-
-    @overload
-    def __call__(
-        self,
-        x: Union[T2, Callable[P, R]],
-        *,
-        sig: bool,
-    ) -> Union[Builds[Type[T2]], BuildsWithSig[Type[R], P]]:
-        ...
-
-    def __call__(
-        self,
-        x: Union[T2, Callable[P, R]],
-        *,
-        sig: bool = False,
-    ) -> Union[Builds[Type[T2]], BuildsWithSig[Type[R], P]]:
-        ...

package/src/tests/samples/overload8.py

@@ -1,89 +0,0 @@
-# This sample tests the expansion of union types during overload matching.
-
-
-from typing import Literal, TypeVar, Union, overload
-
-
-class A:
-    ...
-
-
-class B:
-    ...
-
-
-class C:
-    ...
-
-
-_T1 = TypeVar("_T1", bound=B)
-
-
-@overload
-def overloaded1(x: A) -> str:
-    ...
-
-
-@overload
-def overloaded1(x: _T1) -> _T1:
-    ...
-
-
-def overloaded1(x: Union[A, B]) -> Union[str, B]:
-    ...
-
-
-def func1(a: Union[A, B], b: Union[A, B, C]):
-    v1 = overloaded1(a)
-    reveal_type(v1, expected_text="str | B")
-
-    # This should generate an error because C is not allowed
-    # for the first argument.
-    v2 = overloaded1(b)
-
-
-LargeUnion = Literal["a", "b", "c", "d", "e", "f", "g", 1, 2, 3, 4, 5, 6, 7, 8]
-
-
-@overload
-def overloaded2(a: LargeUnion, b: Literal[2]) -> str:
-    ...
-
-
-@overload
-def overloaded2(a: LargeUnion, b: Literal[3]) -> str:
-    ...
-
-
-@overload
-def overloaded2(a: LargeUnion, b: Literal[4]) -> float:
-    ...
-
-
-@overload
-def overloaded2(a: LargeUnion, b: Literal[9]) -> float:
-    ...
-
-
-@overload
-def overloaded2(a: LargeUnion, b: Literal[10]) -> float:
-    ...
-
-
-def overloaded2(
-    a: LargeUnion, b: Union[LargeUnion, Literal[9, 10]]
-) -> Union[str, float]:
-    ...
-
-
-def func2(a: LargeUnion, b: Literal[2, 3, 4], c: Literal[2, 3, 4, 9, 10]):
-    v1 = overloaded2("a", 2)
-    reveal_type(v1, expected_text="str")
-
-    v2 = overloaded2(a, b)
-    reveal_type(v2, expected_text="str | float")
-
-    # This should generate an error because the expansion of union types
-    # will exceed the max number of expansions (64).
-    v3 = overloaded2(a, c)
-    reveal_type(v2, expected_text="str | float")

package/src/tests/samples/overload9.py

@@ -1,19 +0,0 @@
-# This sample tests that a diagnostic is emitted when an overload
-# function contains an implementation.
-
-from typing import Union, overload
-
-
-@overload
-def func1(x: int) -> int:
-    ...
-
-
-# This should generate an error.
-@overload
-def func1(x: str) -> str:
-    return x
-
-
-def func1(x: Union[int, str]) -> Union[int, str]:
-    return x

package/src/tests/samples/package1/__init__.py

@@ -1,3 +0,0 @@
-
-def foo():
-    pass

package/src/tests/samples/package1/psyche/pysche.py

@@ -1,4 +0,0 @@
-
-def psyche1() -> str:
-    return "3"
-    

package/src/tests/samples/package1/psyche.py

@@ -1,4 +0,0 @@
-
-def psyche1() -> int:
-    return 3
-    

package/src/tests/samples/package1/sub/__init__.py

@@ -1,5 +0,0 @@
-
-from datetime import datetime
-
-def subfoo() -> datetime:
-    return datetime.now()

package/src/tests/samples/package1/sub.py

@@ -1,4 +0,0 @@
-
-def subfoo() -> str:
-    return 'hello'
-

package/src/tests/samples/package1/sub.pyi

@@ -1,2 +0,0 @@
-
-def subfoo() -> int: ...

package/src/tests/samples/paramInference1.py

@@ -1,27 +0,0 @@
-# This sample tests the logic that infers parameter types based on
-# default argument values or annotated base class methods.
-
-
-class Parent:
-    def func1(self, a: int, b: str) -> float:
-        ...
-
-
-class Child(Parent):
-    def func1(self, a, b):
-        reveal_type(self, expected_text="Self@Child")
-        reveal_type(a, expected_text="int")
-        reveal_type(b, expected_text="str")
-        return a
-
-
-def func2(a, b=0, c=None):
-    reveal_type(a, expected_text="Unknown")
-    reveal_type(b, expected_text="int")
-    reveal_type(c, expected_text="Unknown | None")
-
-
-def func3(a=(1, 2), b=[1,2], c={1: 2}):
-    reveal_type(a, expected_text="Unknown")
-    reveal_type(b, expected_text="Unknown")
-    reveal_type(c, expected_text="Unknown")

package/src/tests/samples/paramNames1.py

@@ -1,39 +0,0 @@
-# This sample tests the reportSelfClsParameterName setting.
-
-
-def foo():
-    pass
-
-
-class Class1:
-    # This should generate an error or warning if the setting
-    # is enabled because it's missing a "self" parameter.
-    def foo1():
-        return 3
-
-    # This should generate an error or warning if the setting
-    # is enabled because "self" is misspelled.
-    def foo2(seeeelf):
-        return 4
-
-    # This should generate an error or warning if the setting
-    # is enabled because "self" is misspelled.
-    def foo3(cls):
-        return 4
-
-    @classmethod
-    def foo4(cls):
-        return 4
-
-    @classmethod
-    # This should generate an error or warning if the setting
-    # is enabled because "cls" is expected.
-    def foo5(self):
-        return 4
-
-
-class Metaclass(type):
-    # This should not generate a error because the class derives
-    # from type and is assumed to be a metaclass.
-    def foo1(cls):
-        return 3

package/src/tests/samples/paramSpec1.py

@@ -1,64 +0,0 @@
-# This sample tests error conditions for ParamSpec (PEP 612).
-
-from typing import Any, Callable, List, ParamSpec, Protocol, Tuple, cast
-
-
-TParams = ParamSpec("TParams")
-
-# This should generate an error because ParamSpecs
-# can't be used as a type annotation.
-def foo(a: TParams) -> int:
-    return 1
-
-
-a = 3
-
-# This should generate an error.
-b = cast(TParams, a)
-
-foo(1)
-
-
-def func1(x: Callable[TParams, Any]):
-    # This should generate an error.
-    c: List[TParams] = []
-
-    d: Callable[TParams, int]
-
-    # This should generate an error.
-    e: Callable[TParams, TParams]
-
-    # This should generate an error.
-    f: Callable[[TParams], int]
-
-    # This should generate an error.
-    g: Tuple[TParams]
-
-
-P = ParamSpec("P")
-
-
-class SomeWrapper(Protocol[P]):
-    def __call__(self, *args: P.args, **kwargs: P.kwargs):
-        ...
-
-
-# This should generate an error because P cannot be used with other
-# type arguments.
-def func2(x: SomeWrapper[P, int]):
-    pass
-
-
-# This should generate an error because P cannot be used with other
-# type arguments.
-def func3(x: SomeWrapper[[P, int]]):
-    pass
-
-
-def func4(x: SomeWrapper[P]):
-    pass
-
-
-# This form is considered an error.
-def func5(x: SomeWrapper[[P]]):
-    pass

package/src/tests/samples/paramSpec10.py

@@ -1,57 +0,0 @@
-# This sample tests the use of ParamSpec along with Concatenate in
-# a return type.
-
-from typing import Callable, Protocol, TypeVar, Concatenate, ParamSpec
-from threading import RLock
-import functools
-
-
-class HasLock(Protocol):
-    _lock: RLock
-
-
-S = TypeVar("S", bound=HasLock)
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-def with_lock(func: Callable[Concatenate[S, P], R]) -> Callable[Concatenate[S, P], R]:
-    @functools.wraps(func)
-    def wrapper(self: S, *args: P.args, **kwargs: P.kwargs) -> R:
-        with self._lock:
-            return func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class MyClass:
-    def __init__(self):
-        self._lock = RLock()
-
-    @with_lock
-    def test_1(self, param1: int) -> str:
-        ...
-
-    @with_lock
-    def test_2(self) -> str:
-        ...
-
-
-@with_lock
-def test_3(cls: MyClass, param1: int) -> str:
-    ...
-
-
-testClass = MyClass()
-
-res1 = testClass.test_1(42)
-reveal_type(res1, expected_text="str")
-
-res2 = testClass.test_2()
-reveal_type(res2, expected_text="str")
-
-res3 = test_3(testClass, 42)
-reveal_type(res3, expected_text="str")
-
-res4: Callable[[MyClass, int], str] = with_lock(test_3)
-reveal_type(res4, expected_text="(MyClass, int) -> str")