Enum rustdoc::clean::types::Type

pub(crate) enum Type {
    ResolvedPath {
        path: Path,
        did: DefId,
    },
    DynTrait(Vec<PolyTrait>, Option<Lifetime>),
    Generic(Symbol),
    Primitive(PrimitiveType),
    BareFunction(Box<BareFunctionDecl>),
    Tuple(Vec<Type>),
    Slice(Box<Type>),
    Array(Box<Type>, String),
    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_: Path,
    },
    Infer,
    ImplTrait(Vec<GenericBound>),
}

Rustdoc’s representation of types, mostly based on the hir::Ty.

Variants

ResolvedPath

A named type, which could be a trait.

This is mostly Rustdoc’s version of hir::Path. It has to be different because Rustdoc’s PathSegment can contain cleaned generics.

Fields of ResolvedPath

path: Pathdid: DefId

DynTrait(Vec<PolyTrait>, Option<Lifetime>)

A dyn Trait object: dyn for<'a> Trait<'a> + Send + 'static

Tuple Fields of DynTrait

0: Vec<PolyTrait>1: Option<Lifetime>

Generic(Symbol)

A type parameter.

Tuple Fields of Generic

0: Symbol

Primitive(PrimitiveType)

A primitive (aka, builtin) type.

Tuple Fields of Primitive

0: PrimitiveType

BareFunction(Box<BareFunctionDecl>)

A function pointer: extern "ABI" fn(...) -> ...

Tuple Fields of BareFunction

0: Box<BareFunctionDecl>

Tuple(Vec<Type>)

A tuple type: (i32, &str).

Tuple Fields of Tuple

0: Vec<Type>

Slice(Box<Type>)

A slice type (does not include the &): [i32]

Tuple Fields of Slice

0: Box<Type>

Array(Box<Type>, String)

An array type.

The String field is a stringified version of the array’s length parameter.

Tuple Fields of Array

0: Box<Type>1: String

RawPointer(Mutability, Box<Type>)

A raw pointer type: *const i32, *mut i32

Tuple Fields of RawPointer

0: Mutability1: Box<Type>

BorrowedRef

A reference type: &i32, &'a mut Foo

Fields of BorrowedRef

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

QPath

A qualified path to an associated item: <Type as Trait>::Name

Fields of QPath

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

FIXME: This is a hack that should be removed; see this discussion.

trait_: Path

Infer

A type that is inferred: _

ImplTrait(Vec<GenericBound>)

An impl Trait: impl TraitA + TraitB + ...

Tuple Fields of ImplTrait

0: Vec<GenericBound>

Implementations

impl Type

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

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

Checks if this is a T::Name path for an associated type.

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

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

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

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

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

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<'tcx> Clean<Type> for ProjectionTy<'tcx>

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 even differ between compilations. 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: 72 bytes

Size for each variant:

• ResolvedPath: 63 bytes
• DynTrait: 31 bytes
• Generic: 7 bytes
• Primitive: 1 byte
• BareFunction: 15 bytes
• Tuple: 31 bytes
• Slice: 15 bytes
• Array: 39 bytes
• RawPointer: 15 bytes
• BorrowedRef: 15 bytes
• QPath: 71 bytes
• Infer: 0 bytes
• ImplTrait: 31 bytes