check-typeguard.test

[case testTypeGuardBasic]
from typing_extensions import TypeGuard
class Point: pass
def is_point(a: object) -> TypeGuard[Point]: pass
def main(a: object) -> None:
    if is_point(a):
        reveal_type(a)  # N: Revealed type is "__main__.Point"
    else:
        reveal_type(a)  # N: Revealed type is "builtins.object"
[builtins fixtures/tuple.pyi]

[case testTypeGuardTypeArgsNone]
from typing_extensions import TypeGuard
def foo(a: object) -> TypeGuard:  # E: TypeGuard must have exactly one type argument
    pass
[builtins fixtures/tuple.pyi]

[case testTypeGuardTypeArgsTooMany]
from typing_extensions import TypeGuard
def foo(a: object) -> TypeGuard[int, int]:  # E: TypeGuard must have exactly one type argument
    pass
[builtins fixtures/tuple.pyi]

[case testTypeGuardTypeArgType]
from typing_extensions import TypeGuard
def foo(a: object) -> TypeGuard[42]:  # E: Invalid type: try using Literal[42] instead?
    pass
[builtins fixtures/tuple.pyi]

[case testTypeGuardRepr]
from typing_extensions import TypeGuard
def foo(a: object) -> TypeGuard[int]:
    pass
reveal_type(foo)  # N: Revealed type is "def (a: builtins.object) -> TypeGuard[builtins.int]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardCallArgsNone]
from typing_extensions import TypeGuard
class Point: pass
# TODO: error on the 'def' line (insufficient args for type guard)
def is_point() -> TypeGuard[Point]: pass
def main(a: object) -> None:
    if is_point():
        reveal_type(a)  # N: Revealed type is "builtins.object"
[builtins fixtures/tuple.pyi]

[case testTypeGuardCallArgsMultiple]
from typing_extensions import TypeGuard
class Point: pass
def is_point(a: object, b: object) -> TypeGuard[Point]: pass
def main(a: object, b: object) -> None:
    if is_point(a, b):
        reveal_type(a)  # N: Revealed type is "__main__.Point"
        reveal_type(b)  # N: Revealed type is "builtins.object"
[builtins fixtures/tuple.pyi]

[case testTypeGuardIsBool]
from typing_extensions import TypeGuard
def f(a: TypeGuard[int]) -> None: pass
reveal_type(f)  # N: Revealed type is "def (a: builtins.bool)"
a: TypeGuard[int]
reveal_type(a)  # N: Revealed type is "builtins.bool"
class C:
    a: TypeGuard[int]
reveal_type(C().a)  # N: Revealed type is "builtins.bool"
[builtins fixtures/tuple.pyi]

[case testTypeGuardWithTypeVar]
from typing import TypeVar, Tuple
from typing_extensions import TypeGuard
T = TypeVar('T')
def is_two_element_tuple(a: Tuple[T, ...]) -> TypeGuard[Tuple[T, T]]: pass
def main(a: Tuple[T, ...]):
    if is_two_element_tuple(a):
        reveal_type(a)  # N: Revealed type is "Tuple[T`-1, T`-1]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardNonOverlapping]
from typing import List
from typing_extensions import TypeGuard
def is_str_list(a: List[object]) -> TypeGuard[List[str]]: pass
def main(a: List[object]):
    if is_str_list(a):
        reveal_type(a)  # N: Revealed type is "builtins.list[builtins.str]"
    reveal_type(a)  # N: Revealed type is "builtins.list[builtins.object]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardUnionIn]
from typing import Union
from typing_extensions import TypeGuard
def is_foo(a: Union[int, str]) -> TypeGuard[str]: pass
def main(a: Union[str, int]) -> None:
    if is_foo(a):
        reveal_type(a)  # N: Revealed type is "builtins.str"
    reveal_type(a)  # N: Revealed type is "Union[builtins.str, builtins.int]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardUnionOut]
from typing import Union
from typing_extensions import TypeGuard
def is_foo(a: object) -> TypeGuard[Union[int, str]]: pass
def main(a: object) -> None:
    if is_foo(a):
        reveal_type(a)  # N: Revealed type is "Union[builtins.int, builtins.str]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardNonzeroFloat]
from typing_extensions import TypeGuard
def is_nonzero(a: object) -> TypeGuard[float]: pass
def main(a: int):
    if is_nonzero(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
[builtins fixtures/tuple.pyi]

[case testTypeGuardHigherOrder]
from typing import Callable, TypeVar, Iterable, List
from typing_extensions import TypeGuard
T = TypeVar('T')
R = TypeVar('R')
def filter(f: Callable[[T], TypeGuard[R]], it: Iterable[T]) -> Iterable[R]: pass
def is_float(a: object) -> TypeGuard[float]: pass
a: List[object] = ["a", 0, 0.0]
b = filter(is_float, a)
reveal_type(b)  # N: Revealed type is "typing.Iterable[builtins.float*]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardMethod]
from typing_extensions import TypeGuard
class C:
    def main(self, a: object) -> None:
        if self.is_float(a):
            reveal_type(self)  # N: Revealed type is "__main__.C"
            reveal_type(a)  # N: Revealed type is "builtins.float"
    def is_float(self, a: object) -> TypeGuard[float]: pass
[builtins fixtures/tuple.pyi]

[case testTypeGuardCrossModule]
import guard
from points import Point
def main(a: object) -> None:
    if guard.is_point(a):
        reveal_type(a)  # N: Revealed type is "points.Point"
[file guard.py]
from typing_extensions import TypeGuard
import points
def is_point(a: object) -> TypeGuard[points.Point]: pass
[file points.py]
class Point: pass
[builtins fixtures/tuple.pyi]

[case testTypeGuardBodyRequiresBool]
from typing_extensions import TypeGuard
def is_float(a: object) -> TypeGuard[float]:
    return "not a bool"  # E: Incompatible return value type (got "str", expected "bool")
[builtins fixtures/tuple.pyi]

[case testTypeGuardNarrowToTypedDict]
from typing import Dict, TypedDict
from typing_extensions import TypeGuard
class User(TypedDict):
    name: str
    id: int
def is_user(a: Dict[str, object]) -> TypeGuard[User]:
    return isinstance(a.get("name"), str) and isinstance(a.get("id"), int)
def main(a: Dict[str, object]) -> None:
    if is_user(a):
        reveal_type(a)  # N: Revealed type is "TypedDict('__main__.User', {'name': builtins.str, 'id': builtins.int})"
[builtins fixtures/dict.pyi]
[typing fixtures/typing-typeddict.pyi]

[case testTypeGuardInAssert]
from typing_extensions import TypeGuard
def is_float(a: object) -> TypeGuard[float]: pass
def main(a: object) -> None:
    assert is_float(a)
    reveal_type(a)  # N: Revealed type is "builtins.float"
[builtins fixtures/tuple.pyi]

[case testTypeGuardFromAny]
from typing import Any
from typing_extensions import TypeGuard
def is_objfloat(a: object) -> TypeGuard[float]: pass
def is_anyfloat(a: Any) -> TypeGuard[float]: pass
def objmain(a: object) -> None:
    if is_objfloat(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
    if is_anyfloat(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
def anymain(a: Any) -> None:
    if is_objfloat(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
    if is_anyfloat(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
[builtins fixtures/tuple.pyi]

[case testTypeGuardNegatedAndElse]
from typing import Union
from typing_extensions import TypeGuard
def is_int(a: object) -> TypeGuard[int]: pass
def is_str(a: object) -> TypeGuard[str]: pass
def intmain(a: Union[int, str]) -> None:
    if not is_int(a):
        reveal_type(a)  # N: Revealed type is "Union[builtins.int, builtins.str]"
    else:
        reveal_type(a)  # N: Revealed type is "builtins.int"
def strmain(a: Union[int, str]) -> None:
    if is_str(a):
        reveal_type(a)  # N: Revealed type is "builtins.str"
    else:
        reveal_type(a)  # N: Revealed type is "Union[builtins.int, builtins.str]"
[builtins fixtures/tuple.pyi]

[case testTypeGuardClassMethod]
from typing_extensions import TypeGuard
class C:
    @classmethod
    def is_float(cls, a: object) -> TypeGuard[float]: pass
    def method(self, a: object) -> None:
        if self.is_float(a):
            reveal_type(a)  # N: Revealed type is "builtins.float"
def main(a: object) -> None:
    if C.is_float(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
[builtins fixtures/classmethod.pyi]

[case testTypeGuardRequiresPositionalArgs]
from typing_extensions import TypeGuard
def is_float(a: object, b: object = 0) -> TypeGuard[float]: pass
def main1(a: object) -> None:
    # This is debatable -- should we support these cases?

    if is_float(a=a, b=1):  # E: Type guard requires positional argument
        reveal_type(a)  # N: Revealed type is "builtins.object"

    if is_float(b=1, a=a):  # E: Type guard requires positional argument
        reveal_type(a)  # N: Revealed type is "builtins.object"

    ta = (a,)
    if is_float(*ta):  # E: Type guard requires positional argument
        reveal_type(ta)  # N: Revealed type is "Tuple[builtins.object]"
        reveal_type(a)  # N: Revealed type is "builtins.object"

    la = [a]
    if is_float(*la):  # E: Type guard requires positional argument
        reveal_type(la)  # N: Revealed type is "builtins.list[builtins.object*]"
        reveal_type(a)  # N: Revealed type is "builtins.object*"

[builtins fixtures/tuple.pyi]

[case testTypeGuardOverload-skip]
# flags: --strict-optional
from typing import overload, Any, Callable, Iterable, Iterator, List, Optional, TypeVar
from typing_extensions import TypeGuard

T = TypeVar("T")
R = TypeVar("R")

@overload
def filter(f: Callable[[T], TypeGuard[R]], it: Iterable[T]) -> Iterator[R]: ...
@overload
def filter(f: Callable[[T], bool], it: Iterable[T]) -> Iterator[T]: ...
def filter(*args): pass

def is_int_typeguard(a: object) -> TypeGuard[int]: pass
def is_int_bool(a: object) -> bool: pass

def main(a: List[Optional[int]]) -> None:
    bb = filter(lambda x: x is not None, a)
    reveal_type(bb)  # N: Revealed type is "typing.Iterator[Union[builtins.int, None]]"
    # Also, if you replace 'bool' with 'Any' in the second overload, bb is Iterator[Any]
    cc = filter(is_int_typeguard, a)
    reveal_type(cc)  # N: Revealed type is "typing.Iterator[builtins.int*]"
    dd = filter(is_int_bool, a)
    reveal_type(dd)  # N: Revealed type is "typing.Iterator[Union[builtins.int, None]]"

[builtins fixtures/tuple.pyi]
[typing fixtures/typing-full.pyi]

[case testTypeGuardDecorated]
from typing import TypeVar
from typing_extensions import TypeGuard
T = TypeVar("T")
def decorator(f: T) -> T: pass
@decorator
def is_float(a: object) -> TypeGuard[float]:
    pass
def main(a: object) -> None:
    if is_float(a):
        reveal_type(a)  # N: Revealed type is "builtins.float"
[builtins fixtures/tuple.pyi]

[case testTypeGuardMethodOverride]
from typing_extensions import TypeGuard
class C:
    def is_float(self, a: object) -> TypeGuard[float]: pass
class D(C):
    def is_float(self, a: object) -> bool: pass  # E: Signature of "is_float" incompatible with supertype "C"
[builtins fixtures/tuple.pyi]

[case testTypeGuardInAnd]
from typing import Any
from typing_extensions import TypeGuard
import types
def isclass(a: object) -> bool:
    pass
def ismethod(a: object) -> TypeGuard[float]:
    pass
def isfunction(a: object) -> TypeGuard[str]:
    pass
def isclassmethod(obj: Any) -> bool:
    if ismethod(obj) and obj.__self__ is not None and isclass(obj.__self__):  # E: "float" has no attribute "__self__"
        return True

    return False
def coverage(obj: Any) -> bool:
    if not (ismethod(obj) or isfunction(obj)):
        return True
    return False
[builtins fixtures/classmethod.pyi]

[case testAssignToTypeGuardedVariable1]
from typing_extensions import TypeGuard

class A: pass
class B(A): pass

def guard(a: A) -> TypeGuard[B]:
    pass

a = A()
if not guard(a):
    a = A()
[builtins fixtures/tuple.pyi]

[case testAssignToTypeGuardedVariable2]
from typing_extensions import TypeGuard

class A: pass
class B: pass

def guard(a: A) -> TypeGuard[B]:
    pass

a = A()
if not guard(a):
    a = A()
[builtins fixtures/tuple.pyi]

[case testAssignToTypeGuardedVariable3]
from typing_extensions import TypeGuard

class A: pass
class B: pass

def guard(a: A) -> TypeGuard[B]:
    pass

a = A()
if guard(a):
    reveal_type(a)  # N: Revealed type is "__main__.B"
    a = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
    reveal_type(a)  # N: Revealed type is "__main__.B"
    a = A()
    reveal_type(a)  # N: Revealed type is "__main__.A"
reveal_type(a)  # N: Revealed type is "__main__.A"
[builtins fixtures/tuple.pyi]