Reports typing.cast calls where the source and target types are unrelated.

An error is reported when neither the source type is a subtype of the target, nor the target type is a subtype of the source. Such casts often indicate a logical error, as an instance of one type cannot be assumed to be an instance of the other, and typing.cast does not dynamically validate the type.

This check applies even to types that could theoretically have a common descendant. For example, it will flag a cast between two sibling classes Left and Right that both inherit from Top, because there is no direct inheritance relationship between them.

Example:

from typing import cast

# Non-overlapping types — likely a mistake
cast(int, "a")          # 'str' -> 'int'
cast(list[int], ["a"])  # 'list[str]' -> 'list[int]'

# Recommended explicit escape hatch is to use a "double cast"
cast(int, cast(object, "a"))  # ok

# Legitimate overlapping cases
cast(int, object())    # a valid down cast
cast(object, 1)        # a valid up cast

# By default, the variance of generic type arguments is ignored, so the following is not reported,
# even though list is invariant
int_list = [1, 2, 3]
cast(list[object], int_list)  # ok

The inspection relies on static type information; when a type is unknown, no warning is reported.

Use the Ignore variance of generic type arguments option to control whether the variance of generic type arguments is taken into account. When enabled (the default), the variance is ignored: as long as the corresponding type arguments are in the same inheritance hierarchy, the cast is allowed, so cast(list[object], int_list) is not reported even though list is invariant. Disable it to also report casts that differ only in their (invariant) type arguments.

Use the Ignore TypedDict structure (treat a TypedDict as a dict) option to control whether a TypedDict is treated as a plain dictionary. When enabled (the default), casting a dict to a TypedDict (or vice versa) is allowed, because a TypedDict is a dict at runtime:

from typing import TypedDict, cast

class TD(TypedDict):
    x: int

data: dict[str, object]
cast(TD, data)  # ok

Disable it to report such casts when the dictionary's structure does not match the TypedDict.