Enum rustdoc::clean::types::Type

pub(crate) enum Type {
    Path {
        path: Path,
    },
    DynTrait(Vec<PolyTrait>, Option<Lifetime>),
    Generic(Symbol),
    Primitive(PrimitiveType),
    BareFunction(Box<BareFunctionDecl>),
    Tuple(Vec<Type>),
    Slice(Box<Type>),
    Array(Box<Type>, Box<str>),
    RawPointer(Mutability, Box<Type>),
    BorrowedRef {
        lifetime: Option<Lifetime>,
        mutability: Mutability,
        type_: Box<Type>,
    },
    QPath(Box<QPathData>),
    Infer,
    ImplTrait(Vec<GenericBound>),
}

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

Variants

Path

Fields

path: Path

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.

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

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

Generic(Symbol)

A type parameter.

Primitive(PrimitiveType)

A primitive (aka, builtin) type.

BareFunction(Box<BareFunctionDecl>)

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

Tuple(Vec<Type>)

A tuple type: (i32, &str).

Slice(Box<Type>)

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

Array(Box<Type>, Box<str>)

An array type.

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

RawPointer(Mutability, Box<Type>)

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

BorrowedRef

Fields

lifetime: Option<Lifetime>

mutability: Mutability

type_: Box<Type>

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

QPath(Box<QPathData>)

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

Infer

A type that is inferred: _

ImplTrait(Vec<GenericBound>)

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

Implementations

impl Type

pub(crate) fn without_borrowed_ref(&self) -> &Type

When comparing types for equality, it can help to ignore & wrapping.

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

pub(crate) fn is_doc_subtype_of(&self, other: &Self, cache: &Cache) -> bool

Check if two types are “the same” for documentation purposes.

This is different from Eq, because it knows that things like Placeholder are possible matches for everything.

This relation is not commutative when generics are involved:

# // see types/tests.rs:is_same_generic for the real test
use rustdoc::format::cache::Cache;
use rustdoc::clean::types::{Type, PrimitiveType};
let cache = Cache::new(false);
let generic = Type::Generic(rustc_span::symbol::sym::Any);
let unit = Type::Primitive(PrimitiveType::Unit);
assert!(!generic.is_same(&unit, &cache));
assert!(unit.is_same(&generic, &cache));

An owned type is also the same as its borrowed variants (this is commutative), but &T is not the same as &mut T.

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

pub(crate) fn sugared_async_return_type(self) -> Type

Returns the sugared return type for an async function.

For example, if the return type is impl std::future::Future<Output = i32>, this function will return i32.

Panics

This function will panic if the return type does not match the expected sugaring for async functions.

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_unit(&self) -> bool

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

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

pub(crate) fn def_id(&self, cache: &Cache) -> Option<DefId>

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

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 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 From<Type> for Term

fn from(ty: Type) -> Self

Converts to this type from the input type.

impl FromWithTcx<Type> for Type

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

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, Self: Sized,

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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: 32 bytes

Size for each variant:

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