Class TypeType

mypy/types.py:3474–3581

For types like Type[User] or TypeForm[User | None]. Type[C] annotates variables that are class objects, constrained by the type argument. See PEP 484 for more details. TypeForm[T] annotates variables that hold the result of evaluating a type expression. See PEP 747 for more detai

class TypeType(ProperType):
    """For types like Type[User] or TypeForm[User | None].

    Type[C] annotates variables that are class objects, constrained by
    the type argument.  See PEP 484 for more details.

    TypeForm[T] annotates variables that hold the result of evaluating
    a type expression.  See PEP 747 for more details.

    We may encounter expressions whose values are specific classes;
    those are represented as callables (possibly overloaded)
    corresponding to the class's constructor's signature and returning
    an instance of that class.  The difference with Type[C] is that
    those callables always represent the exact class given as the
    return type; Type[C] represents any class that's a subclass of C,
    and C may also be a type variable or a union (or Any).

    Many questions around subtype relationships between Type[C1] and
    def(...) -> C2 are answered by looking at the subtype
    relationships between C1 and C2, since Type[] is considered
    covariant.

    There's an unsolved problem with constructor signatures (also
    unsolved in PEP 484): calling a variable whose type is Type[C]
    assumes the constructor signature for C, even though a subclass of
    C might completely change the constructor signature.  For now we
    just assume that users of Type[C] are careful not to do that (in
    the future we might detect when they are violating that
    assumption).
    """

    __slots__ = ("item", "is_type_form")

    # This can't be everything, but it can be a class reference,
    # a generic class instance, a union, Any, a type variable...
    item: ProperType

    # If True then this TypeType represents a TypeForm[T].
    # If False then this TypeType represents a Type[C].
    is_type_form: bool

    def __init__(
        self,
        item: Bogus[Instance | AnyType | TypeVarType | TupleType | NoneType | CallableType],
        *,
        line: int = -1,
        column: int = -1,
        is_type_form: bool = False,
    ) -> None:
        """To ensure Type[Union[A, B]] is always represented as Union[Type[A], Type[B]], item of
        type UnionType must be handled through make_normalized static method.
        """
        super().__init__(line, column)
        self.item = item
        self.is_type_form = is_type_form

    @staticmethod
    def make_normalized(