Enum ra_ap_hir_ty::TyKind

pub enum TyKind {
    Adt(AdtId<Interner>, Substitution),
    AssociatedType(AssocTypeId, Substitution),
    Scalar(Scalar),
    Tuple(usize, Substitution),
    Array(Ty),
    Slice(Ty),
    Raw(Mutability, Ty),
    Ref(Mutability, Ty),
    OpaqueType(OpaqueTyId, Substitution),
    FnDef(FnDefId, Substitution),
    Str,
    Never,
    Closure(ClosureId, Substitution),
    ForeignType(ForeignDefId),
    Function(FnPointer),
    Alias(AliasTy),
    Placeholder(PlaceholderIndex),
    BoundVar(BoundVar),
    InferenceVar(InferenceVar, TyVariableKind),
    Dyn(DynTy),
    Unknown,
}

A type.

See also the TyKind enum in rustc (librustc/ty/sty.rs), which represents the same thing (but in a different way).

This should be cheap to clone.

Variants

Adt(AdtId<Interner>, Substitution)

Structures, enumerations and unions.

AssociatedType(AssocTypeId, Substitution)

Represents an associated item like Iterator::Item. This is used when we have tried to normalize a projection like T::Item but couldn’t find a better representation. In that case, we generate an application type like (Iterator::Item)<T>.

Scalar(Scalar)

a scalar type like bool or u32

Tuple(usize, Substitution)

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

Array(Ty)

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

Slice(Ty)

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

Raw(Mutability, Ty)

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

Ref(Mutability, Ty)

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

OpaqueType(OpaqueTyId, Substitution)

This represents a placeholder for an opaque type in situations where we don’t know the hidden type (i.e. currently almost always). This is analogous to the AssociatedType type constructor. It is also used as the type of async block, with one type parameter representing the Future::Output type.

FnDef(FnDefId, Substitution)

The anonymous type of a function declaration/definition. Each function has a unique type, which is output (for a function named foo returning an i32) as fn() -> i32 {foo}.

This includes tuple struct / enum variant constructors as well.

For example the type of bar here:

fn foo() -> i32 { 1 }
let bar = foo; // bar: fn() -> i32 {foo}

Str

The pointee of a string slice. Written as str.

Never

The never type !.

Closure(ClosureId, Substitution)

The type of a specific closure.

The closure signature is stored in a FnPtr type in the first type parameter.

ForeignType(ForeignDefId)

Represents a foreign type declared in external blocks.

Function(FnPointer)

A pointer to a function. Written as fn() -> i32.

For example the type of bar here:

fn foo() -> i32 { 1 }
let bar: fn() -> i32 = foo;

Alias(AliasTy)

An “alias” type represents some form of type alias, such as:

• An associated type projection like <T as Iterator>::Item
• impl Trait types
• Named type aliases like type Foo<X> = Vec<X>

Placeholder(PlaceholderIndex)

A placeholder for a type parameter; for example, T in fn f<T>(x: T) {} when we’re type-checking the body of that function. In this situation, we know this stands for some type, but don’t know the exact type.

BoundVar(BoundVar)

A bound type variable. This is used in various places: when representing some polymorphic type like the type of function fn f<T>, the type parameters get turned into variables; during trait resolution, inference variables get turned into bound variables and back; and in Dyn the Self type is represented with a bound variable as well.

InferenceVar(InferenceVar, TyVariableKind)

A type variable used during type checking.

Dyn(DynTy)

A trait object (dyn Trait or bare Trait in pre-2018 Rust).

The predicates are quantified over the Self type, i.e. Ty::Bound(0) represents the Self type inside the bounds. This is currently implicit; Chalk has the Binders struct to make it explicit, but it didn’t seem worth the overhead yet.

Unknown

A placeholder for a type which could not be computed; this is propagated to avoid useless error messages. Doubles as a placeholder where type variables are inserted before type checking, since we want to try to infer a better type here anyway – for the IDE use case, we want to try to infer as much as possible even in the presence of type errors.

Implementations

impl TyKind

pub fn intern(self, _interner: &Interner) -> Ty

Trait Implementations

impl Clone for TyKind

fn clone(&self) -> TyKind

Returns a copy of the value.

pub 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 Eq for TyKind

impl Hash for TyKind

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<TyKind> for TyKind

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

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

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

This method tests for !=.

impl StructuralEq for TyKind

impl StructuralPartialEq for TyKind