Enum UnevaluatedConstKind 

pub enum UnevaluatedConstKind<I>
where
    I: Interner,
{
    Projection {
        def_id: <I as Interner>::TraitAssocConstId,
    },
    Inherent {
        def_id: <I as Interner>::InherentAssocConstId,
    },
    Free {
        def_id: <I as Interner>::FreeConstAliasId,
    },
    Anon {
        def_id: <I as Interner>::UnevaluatedConstId,
    },
}

UnevaluatedConstKind is extremely similar to AliasTyKind, and likely should be reasoned about and handled in very similar ways. The documentation for AliasTyKind/etc. may be helpful when learning about UnevaluatedConstKind.

Variants

Projection

A projection <Type as Trait>::AssocConst

Fields

def_id: <I as Interner>::TraitAssocConstId

Inherent

An associated constant in an inherent impl

Fields

def_id: <I as Interner>::InherentAssocConstId

Free

A free constant, outside an impl block.

Fields

def_id: <I as Interner>::FreeConstAliasId

Anon

Anonymous constant, e.g. the 1 + 2 in [u8; 1 + 2].

Fields

def_id: <I as Interner>::UnevaluatedConstId

Implementations

impl<I> UnevaluatedConstKind<I>

where I: Interner,

pub fn new_from_def_id( interner: I, def_id: <I as Interner>::DefId, ) -> UnevaluatedConstKind<I>

pub fn def_id(self) -> <I as Interner>::DefId

Trait Implementations

impl<I> Clone for UnevaluatedConstKind<I>

where I: Interner,

fn clone(&self) -> UnevaluatedConstKind<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Copy for UnevaluatedConstKind<I>

where I: Interner,

impl<I> Debug for UnevaluatedConstKind<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, __D> Decodable<__D> for UnevaluatedConstKind<I>

where I: Interner, __D: Decoder, <I as Interner>::TraitAssocConstId: Decodable<__D>, <I as Interner>::InherentAssocConstId: Decodable<__D>, <I as Interner>::FreeConstAliasId: Decodable<__D>, <I as Interner>::UnevaluatedConstId: Decodable<__D>,

fn decode(__decoder: &mut __D) -> UnevaluatedConstKind<I>

impl<I, __E> Encodable<__E> for UnevaluatedConstKind<I>

where I: Interner, __E: Encoder, <I as Interner>::TraitAssocConstId: Encodable<__E>, <I as Interner>::InherentAssocConstId: Encodable<__E>, <I as Interner>::FreeConstAliasId: Encodable<__E>, <I as Interner>::UnevaluatedConstId: Encodable<__E>,

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

impl<I> From<UnevaluatedConstKind<I>> for AliasTermKind<I>

where I: Interner,

fn from(value: UnevaluatedConstKind<I>) -> AliasTermKind<I>

Converts to this type from the input type.

impl<I> Hash for UnevaluatedConstKind<I>

where I: Interner,

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

where __H: Hasher,

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 UnevaluatedConstKind<I>

where J: Interner, <I as Interner>::TraitAssocConstId: Lift<J, Lifted = <J as Interner>::TraitAssocConstId>, <I as Interner>::InherentAssocConstId: Lift<J, Lifted = <J as Interner>::InherentAssocConstId>, <I as Interner>::FreeConstAliasId: Lift<J, Lifted = <J as Interner>::FreeConstAliasId>, I: Interner, <I as Interner>::UnevaluatedConstId: Lift<J, Lifted = <J as Interner>::UnevaluatedConstId>,

type Lifted = UnevaluatedConstKind<J>

fn lift_to_interner(self, interner: J) -> UnevaluatedConstKind<J>

impl<I> PartialEq for UnevaluatedConstKind<I>

where I: Interner,

fn eq(&self, __other: &UnevaluatedConstKind<I>) -> 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> StableHash for UnevaluatedConstKind<I>

where I: Interner, <I as Interner>::TraitAssocConstId: StableHash, <I as Interner>::InherentAssocConstId: StableHash, <I as Interner>::FreeConstAliasId: StableHash, <I as Interner>::UnevaluatedConstId: StableHash,

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

where __Hcx: StableHashCtxt,

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.