@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/tests/samples/typeAlias15.py

@@ -0,0 +1,24 @@
+# This sample tests the case where a generic type alias is specialized
+# with an instantiable class rather than a class instance.
+
+from typing import TypeVar, Sequence, Type
+
+_T = TypeVar("_T", bound=Type[Exception])
+_MaybeSequence = _T | Sequence[_T]
+
+
+class HttpError(Exception):
+    pass
+
+
+def func1(errs: _MaybeSequence[type[Exception]]):
+    pass
+
+
+func1(HttpError)
+func1(Exception)
+
+reveal_type(
+    _MaybeSequence[type[HttpError]],
+    expected_text="Type[Type[HttpError]] | Type[Sequence[Type[HttpError]]]",
+)

package/src/tests/samples/typeAlias16.py

@@ -0,0 +1,24 @@
+# This sample tests that a generic type alias retains a literal type argument
+# when it is specialized.
+
+from typing import Literal, TypeAlias, TypeVar
+
+Mode = Literal["read", "write"]
+T = TypeVar("T")
+Entry: TypeAlias = dict[T, int]
+Entry2: TypeAlias = dict[Mode, int]
+
+
+def f() -> Entry[Mode]:
+    return {"read": 0}
+
+
+def g() -> Entry2:
+    return {"read": 0}
+
+
+def main() -> None:
+    d1 = f()
+    reveal_type(d1, expected_text="dict[Literal['read', 'write'], int]")
+    d2 = g()
+    reveal_type(d2, expected_text="dict[Literal['read', 'write'], int]")

package/src/tests/samples/typeAlias2.py

@@ -0,0 +1,26 @@
+# This sample tests that forward references to type aliases work.
+
+from typing import Dict, Any, Union
+
+
+class Base:
+    @staticmethod
+    def create(data: Dict[str, Any]) -> "Mix":
+        return A()
+
+
+class A(Base):
+    pass
+
+
+class B(Base):
+    pass
+
+
+Mix = Union[A, B]
+
+
+class S:
+    @staticmethod
+    def create(data: Dict[str, Any]) -> "Mix":
+        return A()

package/src/tests/samples/typeAlias3.py

@@ -0,0 +1,35 @@
+# This sample tests that type aliases can consist of
+# partially-specialized classes that can be further
+# specialized.
+
+# pyright: strict
+
+from typing import Callable, Generic, Tuple, Optional, TypeVar
+from typing_extensions import ParamSpec
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+ValidationResult = Tuple[bool, Optional[T]]
+
+
+def foo() -> ValidationResult[str]:
+    return False, "valid"
+
+
+class ClassA(Generic[T]):
+    def __new__(cls, value: T) -> "ClassA[T]":
+        ...
+
+
+TypeAliasA = ClassA[T]
+
+a1 = ClassA(3.0)
+reveal_type(a1, expected_text="ClassA[float]")
+
+a2 = TypeAliasA(3.0)
+reveal_type(a2, expected_text="ClassA[float]")
+
+Func = Callable[P, T]
+AnyFunc = Func[P, int]
+AnyFunc[P]

package/src/tests/samples/typeAlias4.py

@@ -0,0 +1,68 @@
+# This sample tests the handling of the Python 3.9
+# TypeAlias feature as documented in PEP 613.
+
+from typing import Type, TypeAlias as TA, Union
+
+type1: TA = Union[int, str]
+
+type2: TA = "ClassA"
+
+
+class ClassA:
+    pass
+
+
+not_a_type = "ClassA"
+
+
+def requires_string(a: str):
+    pass
+
+
+requires_string(not_a_type)
+
+# This should generate an error because type2 should
+# not be interpreted as a string.
+requires_string(type2)
+
+# This should generate an error because the symbol
+# is later declared as a TypeAlias.
+my_type3 = int
+
+my_type3: TA = Union[int, str]
+
+# This should generate an error because the symbol
+# was previously declared as a TypeAlias.
+my_type3: TA = int
+
+# This should generate an error because the expression
+# on the RHS evaluates to an object, not a class.
+my_type4: TA = 3
+
+# This should generate an error because the expression
+# on the RHS evaluates to an object, not a class.
+my_type5: TA = True
+
+# This should generate an error because the expression
+# on the RHS evaluates to an object, not a class.
+my_type7: TA = list()
+
+# Verify that variables with declarations (other than explicit TypeAlias)
+# are not treated as a type alias.
+SimpleAlias = int
+ExplicitAlias: TA = int
+SimpleNonAlias: Type[int] = int
+
+reveal_type(SimpleAlias, expected_text="Type[int]")
+reveal_type(ExplicitAlias, expected_text="Type[int]")
+reveal_type(SimpleNonAlias, expected_text="Type[int]")
+
+
+class ClassB:
+    my_type1: TA = int
+
+
+def func1():
+    # This should generate an error because type aliases are allowed
+    # only in classes or modules.
+    my_type1: TA = int

package/src/tests/samples/typeAlias5.py

@@ -0,0 +1,56 @@
+# This sample tests type aliases that are unions that include
+# TypeVars.
+
+from datetime import datetime
+from typing import IO, Dict, Generic, List, Literal, Type, TypeVar, Union
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+
+MyUnion1 = Union[int, _T1, str, _T2, List[_T1]]
+
+MyUnion2 = Union[float, datetime]
+
+MyUnion3 = MyUnion1[MyUnion2]
+
+MyUnion4 = MyUnion1[MyUnion2, IO]
+
+# This should generate an error because only two type
+# arguments are expected.
+MyUnion5 = MyUnion1[MyUnion2, IO, str]
+
+MyUnion6 = MyUnion1[Literal[0], Literal["a"]]
+reveal_type(
+    MyUnion6,
+    expected_text="Type[int] | Type[str] | Type[List[Literal[0]]] | Type[Literal[0, 'a']]",
+)
+
+
+class Foo:
+    def __int__(self) -> int:
+        return 0
+
+
+FooT = TypeVar("FooT", bound=Foo)
+FooIsh = Union[int, FooT]
+
+
+class Bar(Foo):
+    def __int__(self) -> int:
+        return super().__int__() + 1
+
+
+v1: FooIsh[Bar] = 42
+v2: FooIsh[Bar] = Bar()
+
+# This should generate an error.
+v3: FooIsh[Type[Bar]] = 42
+
+
+MyTypeAlias = Dict[_T1, _T2]
+
+
+class MyClass1(Generic[_T1, _T2]):
+    # This should generate an error because S and T are bound
+    # type variables.
+    MyTypeAlias = Dict[_T1, _T2]

package/src/tests/samples/typeAlias6.py

@@ -0,0 +1,51 @@
+# This sample tests that certain type aliases cannot be used within
+# call expressions.
+
+from typing import Callable, Optional, Tuple, Type, TypeVar, Union
+
+
+T_Union = Union[int, float]
+
+# This should generate an error
+T_Union(3)
+
+T_Callable = Callable[[int], None]
+
+# This should generate an error
+T_Callable(1)
+
+
+T_Type1 = Type[int]
+
+# This should generate an error
+T_Type1(object)
+
+T_Type2 = type
+T_Type2(object)
+
+T_Optional = Optional[str]
+
+# This should generate an error
+T_Optional(3)
+
+
+T_TypeVar = TypeVar("T_TypeVar")
+
+# This should generate an error
+T_TypeVar()
+
+
+T_Tuple1 = Tuple[int, ...]
+
+# This should generate an error
+T_Tuple1([3, 4])
+
+
+I = int
+
+I(3)
+
+
+T_Tuple2 = tuple[int, ...]
+
+T_Tuple2([3, 4, 5])

package/src/tests/samples/typeAlias7.py

@@ -0,0 +1,50 @@
+# This sample tests the handling of generic type aliases that are
+# defined in terms of other generic type aliases in a nested manner.
+
+from typing import Awaitable, Callable, Generic, TypeVar
+
+
+TSource = TypeVar("TSource")
+TError = TypeVar("TError")
+TResult = TypeVar("TResult")
+TNext = TypeVar("TNext")
+
+
+class Context(Generic[TResult]):
+    Response: TResult
+
+
+class Result(Generic[TResult, TError]):
+    def map(
+        self, mapper: Callable[[Context[TResult]], TResult]
+    ) -> "Result[TResult, TError]":
+        return Result()
+
+
+HttpFuncResult = Result[Context[TResult], TError]
+HttpFuncResultAsync = Awaitable[Result[Context[TResult], TError]]
+
+HttpFunc = Callable[
+    [Context[TNext]],
+    HttpFuncResultAsync[TResult, TError],
+]
+
+HttpHandler = Callable[
+    [
+        HttpFunc[TNext, TResult, TError],
+        Context[TSource],
+    ],
+    HttpFuncResultAsync[TResult, TError],
+]
+
+
+async def run_async(
+    ctx: Context[TSource],
+    handler: HttpHandler[str, TResult, TError, TSource],
+) -> Result[TResult, TError]:
+    result = Result[TResult, TError]()
+
+    def mapper(x: Context[TResult]) -> TResult:
+        return x.Response
+
+    return result.map(mapper)

package/src/tests/samples/typeAlias8.py

@@ -0,0 +1,24 @@
+# This sample verifies that a generic type alias with a Callable
+# works correctly.
+
+# pyright: reportInvalidTypeVarUse=false
+
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+F = Callable[[T], T]
+
+
+def f() -> F[T]:
+    def g(x: T) -> T:
+        ...
+
+    return g
+
+
+g = f()
+v1 = g("foo")
+reveal_type(v1, expected_text="str")
+
+v2 = g(1)
+reveal_type(v2, expected_text="int")

package/src/tests/samples/typeAlias9.py

@@ -0,0 +1,35 @@
+# This sample tests that generic type aliases are properly flagged as
+# partially-unknown types if their type arguments are omitted.
+
+# pyright: reportUnknownParameterType=true, reportMissingTypeArgument=false
+
+from typing import Dict, List, TypeVar
+
+T = TypeVar("T")
+Foo = List[T]
+
+
+# This should generate an error because Foo is missing a type argument,
+# so the type of `f` is partially unknown.
+def foo1(f: Foo) -> None:
+    pass
+
+
+Bar = Foo
+
+
+# This should generate an error because Bar doesn't specialize
+# Foo appropriately.
+def foo2(f: Bar) -> None:
+    pass
+
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+Baz = Dict[K, V]
+
+
+# This should generate an error because Baz is only partially specialized.
+def foo3(f: Baz[int]) -> None:
+    pass

package/src/tests/samples/typeGuard1.py

@@ -0,0 +1,68 @@
+# This sample tests the TypeGuard functionality
+# that allows user-defined functions to perform
+# conditional type narrowing.
+
+# pyright: reportMissingModuleSource=false
+
+import os
+from typing import Any, List, Tuple, TypeVar, Union
+from typing_extensions import TypeGuard
+
+_T = TypeVar("_T")
+
+
+def is_two_element_tuple(a: Tuple[_T, ...]) -> TypeGuard[Tuple[_T, _T]]:
+    return True
+
+
+def func1(a: Tuple[int, ...]):
+    if is_two_element_tuple(a):
+        reveal_type(a, expected_text="Tuple[int, int]")
+    else:
+        reveal_type(a, expected_text="Tuple[int, ...]")
+
+
+def is_string_list(val: List[Any], allow_zero_entries: bool) -> TypeGuard[List[str]]:
+    if allow_zero_entries and len(val) == 0:
+        return True
+    return all(isinstance(x, str) for x in val)
+
+
+def func2(a: List[Union[str, int]]):
+    if is_string_list(a, True):
+        reveal_type(a, expected_text="List[str]")
+    else:
+        reveal_type(a, expected_text="List[str | int]")
+
+
+# This should generate an error because TypeGuard
+# has no type argument.
+def bad1(a: int, b: object) -> TypeGuard:
+    # This is a runtime use of TypeGuard and shouldn't generate an error.
+    if b is TypeGuard:
+        return True
+    return True
+
+
+# This should generate an error because TypeGuard
+# has too many type arguments.
+def bad2(a: int) -> TypeGuard[str, int]:
+    return True
+
+
+# This should generate an error because TypeGuard
+# does not accept an elipsis.
+def bad3(a: int) -> TypeGuard[...]:
+    return True
+
+
+# This should generate an error because TypeGuard
+# has does not accept a module.
+def bad4(a: int) -> TypeGuard[os]:
+    return True
+
+
+def bad5(a: int) -> TypeGuard[int]:
+    # This should generate an error because only
+    # bool values can be returned.
+    return 3

package/src/tests/samples/typeGuard2.py

@@ -0,0 +1,58 @@
+# This sample tests the handling of user-defined type guards (PEP 647)
+# when they are used as callback functions.
+
+# pyright: strict, reportMissingModuleSource=false
+
+from typing import Any, Callable, List, Sequence, TypeVar, overload
+from typing_extensions import TypeGuard
+
+
+_T = TypeVar("_T")
+
+
+def cb1(obj: object) -> TypeGuard[int]:
+    ...
+
+
+def cb2(obj: object) -> bool:
+    ...
+
+
+def simple_filter(list: Sequence[object], fn: Callable[[object], bool]) -> List[object]:
+    ...
+
+
+@overload
+def overloaded_filter(
+    list: Sequence[object], fn: Callable[[object], TypeGuard[_T]]
+) -> Sequence[_T]:
+    ...
+
+
+@overload
+def overloaded_filter(
+    list: Sequence[object], fn: Callable[[object], bool]
+) -> Sequence[object]:
+    ...
+
+
+def overloaded_filter(
+    list: Sequence[object], fn: Callable[[object], Any]
+) -> Sequence[Any]:
+    ...
+
+
+x1 = cb1(1)
+reveal_type(x1, expected_text="bool")
+
+sf1 = simple_filter([], cb1)
+reveal_type(sf1, expected_text="List[object]")
+
+sf2 = simple_filter([], cb2)
+reveal_type(sf2, expected_text="List[object]")
+
+of1 = overloaded_filter([], cb1)
+reveal_type(of1, expected_text="Sequence[int]")
+
+of2 = overloaded_filter([], cb2)
+reveal_type(of2, expected_text="Sequence[object]")

package/src/tests/samples/typeGuard3.py

@@ -0,0 +1,98 @@
+# This sample tests the StrictTypeGuard form.
+
+from typing import Any, Literal, Mapping, Sequence, TypeVar, Union
+from typing_extensions import StrictTypeGuard
+
+
+def is_str1(val: Union[str, int]) -> StrictTypeGuard[str]:
+    return isinstance(val, str)
+
+
+def func1(val: Union[str, int]):
+    if is_str1(val):
+        reveal_type(val, expected_text="str")
+    else:
+        reveal_type(val, expected_text="int")
+
+
+def is_true(o: object) -> StrictTypeGuard[Literal[True]]:
+    ...
+
+
+def func2(val: bool):
+    if not is_true(val):
+        reveal_type(val, expected_text="bool")
+    else:
+        reveal_type(val, expected_text="Literal[True]")
+
+    reveal_type(val, expected_text="bool")
+
+
+def is_list(val: object) -> StrictTypeGuard[list[Any]]:
+    return isinstance(val, list)
+
+
+def func3(val: dict[str, str] | list[str] | list[int] | Sequence[int]):
+    if is_list(val):
+        reveal_type(val, expected_text="list[str] | list[int] | list[Any]")
+    else:
+        reveal_type(val, expected_text="dict[str, str] | Sequence[int]")
+
+
+def func4(val: dict[str, str] | list[str] | list[int] | tuple[int]):
+    if is_list(val):
+        reveal_type(val, expected_text="list[str] | list[int]")
+    else:
+        reveal_type(val, expected_text="dict[str, str] | tuple[int]")
+
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+
+def is_dict(val: Mapping[_K, _V]) -> StrictTypeGuard[dict[_K, _V]]:
+    return isinstance(val, dict)
+
+
+def func5(val: dict[_K, _V] | Mapping[_K, _V]):
+    if not is_dict(val):
+        reveal_type(val, expected_text="Mapping[_K@func5, _V@func5]")
+    else:
+        reveal_type(val, expected_text="dict[_K@func5, _V@func5]")
+
+
+def is_cardinal_direction(val: str) -> StrictTypeGuard[Literal["N", "S", "E", "W"]]:
+    return val in ("N", "S", "E", "W")
+
+
+def func6(direction: Literal["NW", "E"]):
+    if is_cardinal_direction(direction):
+        reveal_type(direction, expected_text="Literal['E']")
+    else:
+        reveal_type(direction, expected_text="Literal['NW']")
+
+
+class Animal:
+    ...
+
+
+class Kangaroo(Animal):
+    ...
+
+
+class Koala(Animal):
+    ...
+
+
+T = TypeVar("T")
+
+
+def is_marsupial(val: Animal) -> StrictTypeGuard[Kangaroo | Koala]:
+    return isinstance(val, Kangaroo | Koala)
+
+
+# This should generate an error because list[T] isn't assignable to list[T | None].
+def has_no_nones(
+    val: list[T | None],
+) -> StrictTypeGuard[list[T]]:
+    return None not in val

package/src/tests/samples/typeIgnore1.py

@@ -0,0 +1,10 @@
+# This sample tests the type: ignore for the entire file.
+
+# type: ignore
+
+# The "type: ignore" should suppress these errors.
+a: int = 3
+b = len(a)
+
+for for for 
+

package/src/tests/samples/typeIgnore2.py

@@ -0,0 +1,20 @@
+# This sample tests the type: ignore for individual lines.
+
+from typing import Dict
+
+
+a: int = 3
+b = len(a) # type: ignore
+
+for for for # type: ignore
+
+c: Dict[str, str] = {
+    3: 3,
+    'hello': 3,
+    3.2: 2.4
+} #type:ignore # something
+
+
+
+
+

package/src/tests/samples/typeIgnore3.py

@@ -0,0 +1,22 @@
+# This sample tests the type: ignore for individual lines.
+# It uses a form of ignore syntax that is not part of the
+# official PEP 484 spec but is a variant supported by mypy.
+
+from typing import Dict
+
+
+a: int = 3
+b = len(a) # type: ignore[1424]
+
+for for for # type: ignore[1424, 244]
+
+c: Dict[str, str] = {
+    3: 3,
+    'hello': 3,
+    3.2: 2.4
+} #type:ignore[999] # something
+
+
+
+
+

package/src/tests/samples/typeIgnore4.py

@@ -0,0 +1,10 @@
+# This sample tests the reportUnnecessaryTypeIgnoreComment diagnostic check
+# as applied to the entire file.
+
+a: str = 3  # type: ignore
+
+# This should emit an error if reportUnnecessaryTypeComment is enabled
+b: str = ""  # type: ignore
+
+# This should emit an error if reportUnnecessaryTypeComment is enabled
+c: int = 3  # type: ignore

package/src/tests/samples/typeIgnore5.py

@@ -0,0 +1,7 @@
+# This sample tests the reportUnnecessaryTypeIgnoreComment diagnostic check
+# as applied to individual lines.
+
+# This should generate an error if reportUnnecessaryTypeIgnoreComment is enabled.
+# type: ignore
+
+b: str = ""