Enum rustc_ast::ast::TyKind

pub enum TyKind {
    Slice(P<Ty>),
    Array(P<Ty>, AnonConst),
    Ptr(MutTy),
    Rptr(Option<Lifetime>, MutTy),
    BareFn(P<BareFnTy>),
    Never,
    Tup(Vec<P<Ty>>),
    Path(Option<QSelf>, Path),
    TraitObject(GenericBounds, TraitObjectSyntax),
    ImplTrait(NodeId, GenericBounds),
    Paren(P<Ty>),
    Typeof(AnonConst),
    Infer,
    ImplicitSelf,
    MacCall(MacCall),
    Err,
    CVarArgs,
}

The various kinds of type recognized by the compiler.

Variants

Slice(P<Ty>)

A variable-length slice ([T]).

Tuple Fields of Slice

0: P<Ty>

Array(P<Ty>, AnonConst)

A fixed length array ([T; n]).

Tuple Fields of Array

0: P<Ty>1: AnonConst

Ptr(MutTy)

A raw pointer (*const T or *mut T).

Tuple Fields of Ptr

0: MutTy

Rptr(Option<Lifetime>, MutTy)

A reference (&'a T or &'a mut T).

Tuple Fields of Rptr

0: Option<Lifetime>1: MutTy

BareFn(P<BareFnTy>)

A bare function (e.g., fn(usize) -> bool).

Tuple Fields of BareFn

0: P<BareFnTy>

Never

The never type (!).

Tup(Vec<P<Ty>>)

A tuple ((A, B, C, D,...)).

Tuple Fields of Tup

0: Vec<P<Ty>>

Path(Option<QSelf>, Path)

A path (module::module::...::Type), optionally “qualified”, e.g., <Vec<T> as SomeTrait>::SomeType.

Type parameters are stored in the Path itself.

Tuple Fields of Path

0: Option<QSelf>1: Path

TraitObject(GenericBounds, TraitObjectSyntax)

A trait object type Bound1 + Bound2 + Bound3 where Bound is a trait or a lifetime.

Tuple Fields of TraitObject

0: GenericBounds1: TraitObjectSyntax

ImplTrait(NodeId, GenericBounds)

An impl Bound1 + Bound2 + Bound3 type where Bound is a trait or a lifetime.

The NodeId exists to prevent lowering from having to generate NodeIds on the fly, which would complicate the generation of opaque type Foo = impl Trait items significantly.

Tuple Fields of ImplTrait

0: NodeId1: GenericBounds

Paren(P<Ty>)

No-op; kept solely so that we can pretty-print faithfully.

Tuple Fields of Paren

0: P<Ty>

Typeof(AnonConst)

Unused for now.

Tuple Fields of Typeof

0: AnonConst

Infer

This means the type should be inferred instead of it having been specified. This can appear anywhere in a type.

ImplicitSelf

Inferred type of a self or &self argument in a method.

MacCall(MacCall)

A macro in the type position.

Tuple Fields of MacCall

0: MacCall

Err

Placeholder for a kind that has failed to be defined.

CVarArgs

Placeholder for a va_list.

Implementations

impl TyKind

pub fn is_implicit_self(&self) -> bool

pub fn is_unit(&self) -> bool

Trait Implementations

impl Clone for TyKind

fn clone(&self) -> TyKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TyKind

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

Formats the value using the given formatter.

impl<__D: Decoder> Decodable<__D> for TyKind

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<__E: Encoder> Encodable<__E> for TyKind

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

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:

• Slice: 15 bytes
• Array: 31 bytes
• Ptr: 23 bytes
• Rptr: 39 bytes
• BareFn: 15 bytes
• Never: 0 bytes
• Tup: 31 bytes
• Path: 71 bytes
• TraitObject: 31 bytes
• ImplTrait: 31 bytes
• Paren: 15 bytes
• Typeof: 23 bytes
• Infer: 0 bytes
• ImplicitSelf: 0 bytes
• MacCall: 71 bytes
• Err: 0 bytes
• CVarArgs: 0 bytes