Enum TyKind

pub enum TyKind {
    Slice(P<Ty>),
    Array(P<Ty>, AnonConst),
    Ptr(MutTy),
    Ref(Option<Lifetime>, MutTy),
    PinnedRef(Option<Lifetime>, MutTy),
    BareFn(P<BareFnTy>),
    UnsafeBinder(P<UnsafeBinderTy>),
    Never,
    Tup(ThinVec<P<Ty>>),
    Path(Option<P<QSelf>>, Path),
    TraitObject(GenericBounds, TraitObjectSyntax),
    ImplTrait(NodeId, GenericBounds),
    Paren(P<Ty>),
    Typeof(AnonConst),
    Infer,
    ImplicitSelf,
    MacCall(P<MacCall>),
    CVarArgs,
    Pat(P<Ty>, P<Pat>),
    Dummy,
    Err(ErrorGuaranteed),
}

The various kinds of type recognized by the compiler.

Variants

Slice(P<Ty>)

A variable-length slice ([T]).

Array(P<Ty>, AnonConst)

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

Ptr(MutTy)

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

Ref(Option<Lifetime>, MutTy)

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

PinnedRef(Option<Lifetime>, MutTy)

A pinned reference (&'a pin const T or &'a pin mut T).

Desugars into Pin<&'a T> or Pin<&'a mut T>.

BareFn(P<BareFnTy>)

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

UnsafeBinder(P<UnsafeBinderTy>)

An unsafe existential lifetime binder (e.g., unsafe<'a> &'a ()).

Never

The never type (!).

Tup(ThinVec<P<Ty>>)

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

Path(Option<P<QSelf>>, Path)

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

Type parameters are stored in the Path itself.

TraitObject(GenericBounds, TraitObjectSyntax)

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

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.

Paren(P<Ty>)

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

Typeof(AnonConst)

Unused for now.

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(P<MacCall>)

A macro in the type position.

CVarArgs

Placeholder for a va_list.

Pat(P<Ty>, P<Pat>)

Pattern types like pattern_type!(u32 is 1..=), which is the same as NonZero<u32>, just as part of the type system.

Dummy

Sometimes we need a dummy value when no error has occurred.

Err(ErrorGuaranteed)

Placeholder for a kind that has failed to be defined.

Implementations

impl TyKind

pub fn is_implicit_self(&self) -> bool

pub fn is_unit(&self) -> bool

pub fn is_simple_path(&self) -> Option<Symbol>

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: SpanDecoder> Decodable<__D> for TyKind

fn decode(__decoder: &mut __D) -> Self

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

fn encode(&self, __encoder: &mut __E)

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

Size for each variant:

• Slice: 15 bytes
• Array: 31 bytes
• Ptr: 23 bytes
• Ref: 39 bytes
• PinnedRef: 39 bytes
• BareFn: 15 bytes
• UnsafeBinder: 15 bytes
• Never: 0 bytes
• Tup: 15 bytes
• Path: 39 bytes
• TraitObject: 31 bytes
• ImplTrait: 31 bytes
• Paren: 15 bytes
• Typeof: 23 bytes
• Infer: 0 bytes
• ImplicitSelf: 0 bytes
• MacCall: 15 bytes
• CVarArgs: 0 bytes
• Pat: 23 bytes
• Dummy: 0 bytes
• Err: 0 bytes