Class UnionType

mypy/types.py:3306–3413

The union type Union[T1, ..., Tn] (at least one type argument).

class UnionType(ProperType):
    """The union type Union[T1, ..., Tn] (at least one type argument)."""

    __slots__ = (
        "items",
        "is_evaluated",
        "uses_pep604_syntax",
        "original_str_expr",
        "original_str_fallback",
    )

    def __init__(
        self,
        items: Sequence[Type],
        line: int = -1,
        column: int = -1,
        *,
        is_evaluated: bool = True,
        uses_pep604_syntax: bool = False,
    ) -> None:
        super().__init__(line, column)
        # We must keep this false to avoid crashes during semantic analysis.
        # TODO: maybe switch this to True during type-checking pass?
        self.items = flatten_nested_unions(items, handle_type_alias_type=False)
        # is_evaluated should be set to false for type comments and string literals
        self.is_evaluated = is_evaluated
        # uses_pep604_syntax is True if Union uses OR syntax (X | Y)
        self.uses_pep604_syntax = uses_pep604_syntax
        # The meaning of these two is the same as for UnboundType. A UnionType can be
        # return by type parser from a string "A|B", and we need to be able to fall back
        # to plain string, when such a string appears inside a Literal[...].
        self.original_str_expr: str | None = None
        self.original_str_fallback: str | None = None

    def can_be_true_default(self) -> bool:
        return any(item.can_be_true for item in self.items)

    def can_be_false_default(self) -> bool:
        return any(item.can_be_false for item in self.items)

    def __hash__(self) -> int:
        return hash(frozenset(self.items))

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, UnionType):
            return NotImplemented
        if self is other:
            return True
        return frozenset(self.items) == frozenset(other.items)

    @overload
    @staticmethod
    def make_union(
        items: Sequence[ProperType], line: int = -1, column: int = -1
    ) -> ProperType: ...

    @overload
    @staticmethod