Enum AliasTermKind 

pub enum AliasTermKind<I: Interner> {
    ProjectionTy {
        def_id: I::TraitAssocTyId,
    },
    InherentTy {
        def_id: I::InherentAssocTyId,
    },
    OpaqueTy {
        def_id: I::OpaqueTyId,
    },
    FreeTy {
        def_id: I::FreeTyAliasId,
    },
    UnevaluatedConst {
        def_id: I::UnevaluatedConstId,
    },
    ProjectionConst {
        def_id: I::TraitAssocConstId,
    },
    FreeConst {
        def_id: I::FreeConstAliasId,
    },
    InherentConst {
        def_id: I::InherentAssocConstId,
    },
}

Variants

ProjectionTy

A projection <Type as Trait>::AssocType.

Can get normalized away if monomorphic enough.

The def_id is the DefId of the TraitItem for the associated type.

Note that the def_id is not the DefId of the TraitRef containing this associated type, which is in interner.associated_item(def_id).container, aka. interner.parent(def_id).

Fields

def_id: I::TraitAssocTyId

InherentTy

An associated type in an inherent impl

The def_id is the DefId of the ImplItem for the associated type.

Fields

def_id: I::InherentAssocTyId

OpaqueTy

An opaque type (usually from impl Trait in type aliases or function return types)

def_id is the DefId of the OpaqueType item.

Can only be normalized away in PostAnalysis mode or its defining scope.

During codegen, interner.type_of(def_id) can be used to get the type of the underlying type if the type is an opaque.

Fields

def_id: I::OpaqueTyId

FreeTy

A type alias that actually checks its trait bounds.

Currently only used if the type alias references opaque types. Can always be normalized away.

Fields

def_id: I::FreeTyAliasId

UnevaluatedConst

An unevaluated anonymous constants.

Fields

def_id: I::UnevaluatedConstId

ProjectionConst

An unevaluated const coming from an associated const.

Fields

def_id: I::TraitAssocConstId

FreeConst

A top level const item not part of a trait or impl.

Fields

def_id: I::FreeConstAliasId

InherentConst

An associated const in an inherent impl

Fields

def_id: I::InherentAssocConstId

Implementations

impl<I: Interner> AliasTermKind<I>

pub fn descr(self) -> &'static str

pub fn is_type(self) -> bool

pub fn def_id(self) -> I::DefId

Trait Implementations

impl<I> Clone for AliasTermKind<I>

where I: Interner,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for AliasTermKind<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I: Interner, __D: Decoder> Decodable<__D> for AliasTermKind<I>

where I::TraitAssocTyId: Decodable<__D>, I::InherentAssocTyId: Decodable<__D>, I::OpaqueTyId: Decodable<__D>, I::FreeTyAliasId: Decodable<__D>, I::UnevaluatedConstId: Decodable<__D>, I::TraitAssocConstId: Decodable<__D>, I::FreeConstAliasId: Decodable<__D>, I::InherentAssocConstId: Decodable<__D>,

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

impl<I: Interner, __E: Encoder> Encodable<__E> for AliasTermKind<I>

where I::TraitAssocTyId: Encodable<__E>, I::InherentAssocTyId: Encodable<__E>, I::OpaqueTyId: Encodable<__E>, I::FreeTyAliasId: Encodable<__E>, I::UnevaluatedConstId: Encodable<__E>, I::TraitAssocConstId: Encodable<__E>, I::FreeConstAliasId: Encodable<__E>, I::InherentAssocConstId: Encodable<__E>,

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

impl<I: Interner> From<AliasTyKind<I>> for AliasTermKind<I>

fn from(value: AliasTyKind<I>) -> Self

Converts to this type from the input type.

impl<I> Hash for AliasTermKind<I>

where I: Interner,

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, J> Lift<J> for AliasTermKind<I>

where I: Interner, J: Interner, I::TraitAssocTyId: Lift<J, Lifted = J::TraitAssocTyId>, I::InherentAssocTyId: Lift<J, Lifted = J::InherentAssocTyId>, I::OpaqueTyId: Lift<J, Lifted = J::OpaqueTyId>, I::FreeTyAliasId: Lift<J, Lifted = J::FreeTyAliasId>, I::UnevaluatedConstId: Lift<J, Lifted = J::UnevaluatedConstId>, I::TraitAssocConstId: Lift<J, Lifted = J::TraitAssocConstId>, I::FreeConstAliasId: Lift<J, Lifted = J::FreeConstAliasId>, I::InherentAssocConstId: Lift<J, Lifted = J::InherentAssocConstId>,

type Lifted = AliasTermKind<J>

fn lift_to_interner(self, interner: J) -> Self::Lifted

impl<I> PartialEq for AliasTermKind<I>

where I: Interner,

fn eq(&self, __other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: Interner> StableHash for AliasTermKind<I>

where I::TraitAssocTyId: StableHash, I::InherentAssocTyId: StableHash, I::OpaqueTyId: StableHash, I::FreeTyAliasId: StableHash, I::UnevaluatedConstId: StableHash, I::TraitAssocConstId: StableHash, I::FreeConstAliasId: StableHash, I::InherentAssocConstId: StableHash,

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl<I> Copy for AliasTermKind<I>

where I: Interner,

impl<I> Eq for AliasTermKind<I>

where I: Interner,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.