Class LiteralType

mypy/types.py:3189–3303

The type of a Literal instance. Literal[Value] A Literal always consists of: 1. A native Python object corresponding to the contained inner value 2. A fallback for this Literal. The fallback also corresponds to the parent type this Literal subtypes. For example, 'Literal[42

class LiteralType(ProperType):
    """The type of a Literal instance. Literal[Value]

    A Literal always consists of:

    1. A native Python object corresponding to the contained inner value
    2. A fallback for this Literal. The fallback also corresponds to the
       parent type this Literal subtypes.

    For example, 'Literal[42]' is represented as
    'LiteralType(value=42, fallback=instance_of_int)'

    As another example, `Literal[Color.RED]` (where Color is an enum) is
    represented as `LiteralType(value="RED", fallback=instance_of_color)'.
    """

    __slots__ = ("value", "fallback", "_hash")

    def __init__(
        self, value: LiteralValue, fallback: Instance, line: int = -1, column: int = -1
    ) -> None:
        super().__init__(line, column)
        self.value = value
        self.fallback = fallback

    # NOTE: Enum types are always truthy by default, but this can be changed
    #       in subclasses, so we need to get the truthyness from the Enum
    #       type rather than base it on the value (which is a non-empty
    #       string for enums, so always truthy)
    # TODO: We should consider moving this branch to the `can_be_true`
    #       `can_be_false` properties instead, so the truthyness only
    #       needs to be determined once per set of Enum literals.
    #       However, the same can be said for `TypeAliasType` in some
    #       cases and we only set the default based on the type it is
    #       aliasing. So if we decide to change this, we may want to
    #       change that as well. perf_compare output was inconclusive
    #       but slightly favored this version, probably because we have
    #       almost no test cases where we would redundantly compute
    #       `can_be_false`/`can_be_true`.
    def can_be_false_default(self) -> bool:
        if self.fallback.type.is_enum:
            return self.fallback.can_be_false
        return not self.value

    def can_be_true_default(self) -> bool:
        if self.fallback.type.is_enum:
            return self.fallback.can_be_true
        return bool(self.value)

    def accept(self, visitor: TypeVisitor[T]) -> T:
        return visitor.visit_literal_type(self)

    def __hash__(self) -> int:
        # Intentionally a subset of __eq__ for perf
        return hash(self.value)

    def __eq__(self, other: object) -> bool:
        if isinstance(other, LiteralType):