Enum rustdoc::clean::types::Type

pub(crate) enum Type {
    ResolvedPath {
        path: Path,
        param_names: Option<Vec<GenericBound>>,
        did: DefId,
        is_generic: bool,
    },
    Generic(Symbol),
    Primitive(PrimitiveType),
    BareFunction(Box<BareFunctionDecl>),
    Tuple(Vec<Type>),
    Slice(Box<Type>),
    Array(Box<Type>, String),
    Never,
    RawPointer(Mutability, Box<Type>),
    BorrowedRef {
        lifetime: Option<Lifetime>,
        mutability: Mutability,
        type_: Box<Type>,
    },
    QPath {
        name: Symbol,
        self_type: Box<Type>,
        self_def_id: Option<DefId>,
        trait_: Box<Type>,
    },
    Infer,
    ImplTrait(Vec<GenericBound>),
}

A representation of a type suitable for hyperlinking purposes. Ideally, one can get the original type out of the AST/TyCtxt given one of these, if more information is needed. Most importantly, it does not preserve mutability or boxes.

Variants

ResolvedPath

Structs/enums/traits (most that would be an hir::TyKind::Path).

Fields of ResolvedPath

path: Pathparam_names: Option<Vec<GenericBound>>did: DefIdis_generic: bool

true if is a T::Name path for associated types.

Generic(Symbol)

For parameterized types, so the consumer of the JSON don’t go looking for types which don’t exist anywhere.

Primitive(PrimitiveType)

Primitives are the fixed-size numeric types (plus int/usize/float), char, arrays, slices, and tuples.

BareFunction(Box<BareFunctionDecl>)

extern "ABI" fn

Tuple(Vec<Type>)

Slice(Box<Type>)

Array(Box<Type>, String)

The String field is about the size or the constant representing the array’s length.

Never

RawPointer(Mutability, Box<Type>)

BorrowedRef

Fields of BorrowedRef

lifetime: Option<Lifetime>mutability: Mutabilitytype_: Box<Type>

QPath

Fields of QPath

name: Symbolself_type: Box<Type>self_def_id: Option<DefId>trait_: Box<Type>

Infer

ImplTrait(Vec<GenericBound>)

Implementations

impl Type

pub(crate) fn primitive_type(&self) -> Option<PrimitiveType>

pub(crate) fn is_generic(&self) -> bool

pub(crate) fn is_self_type(&self) -> bool

pub(crate) fn generics(&self) -> Option<Vec<&Type>>

pub(crate) fn bindings(&self) -> Option<&[TypeBinding]>

pub(crate) fn is_full_generic(&self) -> bool

pub(crate) fn is_primitive(&self) -> bool

pub(crate) fn projection(&self) -> Option<(&Type, DefId, Symbol)>

impl Type

fn inner_def_id(&self, cache: Option<&Cache>) -> Option<DefId>

impl Type

pub(crate) fn print<'b, 'a: 'b, 'tcx: 'a>(
    &'a self,
    cx: &'a Context<'tcx>
) -> impl Display + 'b + Captures<'tcx>

Trait Implementations

impl Clean<Type> for (TraitRef<'_>, &[TypeBinding])

fn clean(&self, cx: &mut DocContext<'_>) -> Type

impl<'tcx> Clean<Type> for ProjectionTy<'tcx>

fn clean(&self, cx: &mut DocContext<'_>) -> Type

impl Clean<Type> for TraitRef<'_>

fn clean(&self, cx: &mut DocContext<'_>) -> Type

impl Clean<Type> for Ty<'_>

fn clean(&self, cx: &mut DocContext<'_>) -> Type

impl<'tcx> Clean<Type> for Ty<'tcx>

fn clean(&self, cx: &mut DocContext<'_>) -> Type

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Type

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromWithTcx<Type> for Type

fn from_tcx(ty: Type, tcx: TyCtxt<'_>) -> Self

impl GetDefId for Type

fn def_id(&self) -> Option<DefId>

Use this method to get the DefId of a clean AST node. This will return None when called on a primitive clean::Type. Use Self::def_id_full if you want to include primitives.

fn def_id_full(&self, cache: &Cache) -> Option<DefId>

Use this method to get the DefId of a clean AST node, including PrimitiveTypes.

impl Hash for Type

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Type> for Type

fn eq(&self, other: &Type) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Type) -> bool

This method tests for !=.

impl Eq for Type

impl StructuralEq for Type

impl StructuralPartialEq for Type

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 96 bytes