Enum Type

pub(crate) enum Type {
    Path {
        path: Path,
    },
    DynTrait(Vec<PolyTrait>, Option<Lifetime>),
    Generic(Symbol),
    SelfTy,
    Primitive(PrimitiveType),
    BareFunction(Box<BareFunctionDecl>),
    Tuple(Vec<Type>),
    Slice(Box<Type>),
    Array(Box<Type>, Box<str>),
    Pat(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

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

path: Path

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

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

Generic(Symbol)

A type parameter.

SelfTy

The Self type.

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.

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

RawPointer(Mutability, Box<Type>)

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

BorrowedRef

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

Fields

lifetime: Option<Lifetime>

mutability: Mutability

type_: Box<Type>

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:

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 generic_args(&self) -> Option<&GenericArgs>

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)>

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 FromClean<Type> for Type

fn from_clean(ty: Type, renderer: &JsonRenderer<'_>) -> 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 for Type

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq 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: 32 bytes
• DynTrait: 32 bytes
• Generic: 12 bytes
• SelfTy: 0 bytes
• Primitive: 9 bytes
• BareFunction: 16 bytes
• Tuple: 32 bytes
• Slice: 16 bytes
• Array: 32 bytes
• Pat: 32 bytes
• RawPointer: 24 bytes
• BorrowedRef: 24 bytes
• QPath: 16 bytes
• Infer: 0 bytes
• ImplTrait: 32 bytes