Enum rustc::ty::TypeVariants

pub enum TypeVariants<'tcx> {
    TyBool,
    TyChar,
    TyInt(IntTy),
    TyUint(UintTy),
    TyFloat(FloatTy),
    TyEnum(AdtDef<'tcx>, &'tcx Substs<'tcx>),
    TyStruct(AdtDef<'tcx>, &'tcx Substs<'tcx>),
    TyBox(Ty<'tcx>),
    TyStr,
    TyArray(Ty<'tcx>, usize),
    TySlice(Ty<'tcx>),
    TyRawPtr(TypeAndMut<'tcx>),
    TyRef(&'tcx Region, TypeAndMut<'tcx>),
    TyFnDef(DefId, &'tcx Substs<'tcx>, &'tcx BareFnTy<'tcx>),
    TyFnPtr(&'tcx BareFnTy<'tcx>),
    TyTrait(Box<TraitTy<'tcx>>),
    TyClosure(DefId, ClosureSubsts<'tcx>),
    TyTuple(&'tcx [Ty<'tcx>]),
    TyProjection(ProjectionTy<'tcx>),
    TyParam(ParamTy),
    TyInfer(InferTy),
    TyError,
}

Unstable (rustc_private)

Variants

TyBool

Unstable (rustc_private)

The primitive boolean type. Written as bool.

TyChar

Unstable (rustc_private)

The primitive character type; holds a Unicode scalar value (a non-surrogate code point). Written as char.

TyInt(IntTy)

Unstable (rustc_private)

A primitive signed integer type. For example, i32.

TyUint(UintTy)

Unstable (rustc_private)

A primitive unsigned integer type. For example, u32.

TyFloat(FloatTy)

Unstable (rustc_private)

A primitive floating-point type. For example, f64.

TyEnum(AdtDef<'tcx>, &'tcx Substs<'tcx>)

Unstable (rustc_private)

An enumerated type, defined with enum.

Substs here, possibly against intuition, may contain TyParams. That is, even after substitution it is possible that there are type variables. This happens when the TyEnum corresponds to an enum definition and not a concrete use of it. This is true for TyStruct as well.

TyStruct(AdtDef<'tcx>, &'tcx Substs<'tcx>)

Unstable (rustc_private)

A structure type, defined with struct.

See warning about substitutions for enumerated types.

TyBox(Ty<'tcx>)

Unstable (rustc_private)

Box<T>; this is nominally a struct in the documentation, but is special-cased internally. For example, it is possible to implicitly move the contents of a box out of that box, and methods of any type can have type Box<Self>.

TyStr

Unstable (rustc_private)

The pointee of a string slice. Written as str.

TyArray(Ty<'tcx>, usize)

Unstable (rustc_private)

An array with the given length. Written as [T; n].

TySlice(Ty<'tcx>)

Unstable (rustc_private)

The pointee of an array slice. Written as [T].

TyRawPtr(TypeAndMut<'tcx>)

Unstable (rustc_private)

A raw pointer. Written as *mut T or *const T

TyRef(&'tcx Region, TypeAndMut<'tcx>)

Unstable (rustc_private)

A reference; a pointer with an associated lifetime. Written as &a mut T or &'a T.

TyFnDef(DefId, &'tcx Substs<'tcx>, &'tcx BareFnTy<'tcx>)

Unstable (rustc_private)

The anonymous type of a function declaration/definition. Each function has a unique type.

TyFnPtr(&'tcx BareFnTy<'tcx>)

Unstable (rustc_private)

A pointer to a function. Written as fn() -> i32. FIXME: This is currently also used to represent the callee of a method; see ty::MethodCallee etc.

TyTrait(Box<TraitTy<'tcx>>)

Unstable (rustc_private)

A trait, defined with trait.

TyClosure(DefId, ClosureSubsts<'tcx>)

Unstable (rustc_private)

The anonymous type of a closure. Used to represent the type of |a| a.

TyTuple(&'tcx [Ty<'tcx>])

Unstable (rustc_private)

A tuple type. For example, (i32, bool).

TyProjection(ProjectionTy<'tcx>)

Unstable (rustc_private)

The projection of an associated type. For example, <T as Trait<..>>::N.

TyParam(ParamTy)

Unstable (rustc_private)

A type parameter; for example, T in `fn f(x: T) {}

TyInfer(InferTy)

Unstable (rustc_private)

A type variable used during type-checking.

TyError

Unstable (rustc_private)

A placeholder for a type which could not be computed; this is propagated to avoid useless error messages.

Trait Implementations

impl<'tcx> Display for TypeVariants<'tcx>

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

Formats the value using the given formatter.

Derived Implementations

impl<'tcx> Debug for TypeVariants<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Hash for TypeVariants<'tcx>

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<'tcx> Eq for TypeVariants<'tcx>

impl<'tcx> PartialEq for TypeVariants<'tcx>

fn eq(&self, __arg_0: &TypeVariants<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &TypeVariants<'tcx>) -> bool

This method tests for !=.

impl<'tcx> Clone for TypeVariants<'tcx>

fn clone(&self) -> TypeVariants<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.