Enum rustdoc::clean::TypeUnstable [-] [+] [src]

pub enum Type {
    ResolvedPath {
        path: Path,
        typarams: Option<Vec<TyParamBound>>,
        did: DefId,
    },
    Generic(String),
    Primitive(PrimitiveType),
    BareFunction(Box<BareFunctionDecl>),
    Tuple(Vec<Type>),
    Vector(Box<Type>),
    FixedVector(Box<Type>, String),
    Bottom,
    Unique(Box<Type>),
    RawPointer(Mutability, Box<Type>),
    BorrowedRef {
        lifetime: Option<Lifetime>,
        mutability: Mutability,
        type_: Box<Type>,
    },
    QPath {
        name: String,
        self_type: Box<Type>,
        trait_: Box<Type>,
    },
    Infer,
    PolyTraitRef(Vec<TyParamBound>),
}

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

Variants

ResolvedPath

structs/enums/traits (anything that'd be an ast::TyPath)

Fields

path
typarams
did
Generic

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

Primitive

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

BareFunction

extern "ABI" fn

Tuple
Vector
FixedVector
Bottom

aka TyBot

Unique
RawPointer
BorrowedRef

Fields

lifetime
mutability
type_
QPath

Fields

name
self_type
trait_
Infer
PolyTraitRef

Methods

impl Type

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

Trait Implementations

impl Display for Type

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

Derived Implementations

impl Debug for Type

fn fmt(&self, __arg_0: &mut Formatter) -> Result

impl PartialEq for Type

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

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

impl Decodable for Type

fn decode<__D: Decoder>(__arg_0: &mut __D) -> Result<Type, __D>

impl Encodable for Type

fn encode<__S: Encoder>(&self, __arg_0: &mut __S) -> Result<(), __S>

impl Clone for Type

fn clone(&self) -> Type

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