Enum AliasConstKind 

pub enum AliasConstKind<I>
where
    I: Interner,
{
    Projection {
        def_id: <I as Interner>::TraitAssocConstId,
    },
    InherentSelf {
        def_id: <I as Interner>::InherentAssocConstId,
    },
    InherentImpl {
        def_id: <I as Interner>::InherentAssocConstId,
    },
    Free {
        def_id: <I as Interner>::FreeConstAliasId,
    },
    Anon {
        def_id: <I as Interner>::AnonConstId,
    },
}

AliasConstKind 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 AliasConstKind.

Variants

Projection

A projection <Type as Trait>::AssocConst

Fields

def_id: <I as Interner>::TraitAssocConstId

InherentSelf

An associated const in an inherent impl.

The generic args are in “Self form”, i.e. there is a single Self type parameter, followed by any GAT args on the inherent const itself.

The “impl form” args can be obtained by generating fresh vars for each of the impl params, instantiating the impl block’s Self type with the fresh vars, equating the resulting type with the Self generic argument, and using the result of what the fresh vars resolved to as the “impl form” args. Doing so without considering the extra predicates generated by the equate is a lossy operation, consider the following impl block:

impl<T> Struct<'static, T> {
    const ASSOC<A>: () = ();
}

If we have Struct::<'a, u32>::Assoc<usize>, the Self args form would be [Struct<'a, u32>, usize]. The “impl form” args would be [u32, usize], with an extra constraint generated that 'a == 'static. Disregarding this extra constraint would be wrong.

Hence, when HIR lowering wants to construct an inherent alias, it must use the “Self form” to let the trait solver do the equate and consider additional constraints.

FIXME(inherent_associated_types): This ideally ought be a list of candidate DefIds that a path could resolve to, then the trait solver does the above-written routine to figure out which exact impl to use. InherentSelf could be conceptually be thought of as corresponding to Projection where the def_id is a trait, and InherentImpl is Projection where the def_id is an impl.

Fields

def_id: <I as Interner>::InherentAssocConstId

InherentImpl

An associated const in an inherent impl. See Self::InherentSelf for a description on the difference between InherentSelf and InherentImpl.

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>::AnonConstId

Implementations

impl<I> AliasConstKind<I>

where I: Interner,

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

pub fn is_type_const(self, interner: I) -> bool

pub fn def_span(self, interner: I) -> <I as Interner>::Span

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

Trait Implementations

impl<I> Clone for AliasConstKind<I>

where I: Interner,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Copy for AliasConstKind<I>

where I: Interner,

impl<I> Debug for AliasConstKind<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 AliasConstKind<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>::AnonConstId: Decodable<__D>,

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

impl<I, __E> Encodable<__E> for AliasConstKind<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>::AnonConstId: Encodable<__E>,

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

impl<I> From<AliasConstKind<I>> for AliasTermKind<I>

where I: Interner,

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

Converts to this type from the input type.

impl<I, __V> GenericTypeVisitable<__V> for AliasConstKind<I>

where I: Interner, <I as Interner>::TraitAssocConstId: GenericTypeVisitable<__V>, <I as Interner>::InherentAssocConstId: GenericTypeVisitable<__V>, <I as Interner>::FreeConstAliasId: GenericTypeVisitable<__V>, <I as Interner>::AnonConstId: GenericTypeVisitable<__V>,

fn generic_visit_with(&self, __visitor: &mut __V)

impl<I> Hash for AliasConstKind<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 AliasConstKind<I>

where I: Interner + LiftInto<J>, J: Interner,

type Lifted = AliasConstKind<J>

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

impl<I> PartialEq for AliasConstKind<I>

where I: Interner,

fn eq(&self, __other: &AliasConstKind<I>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I> StableHash for AliasConstKind<I>

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

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

where __Hcx: StableHashCtxt,

impl<I> TypeFoldable<I> for AliasConstKind<I>

where I: Interner, <I as Interner>::TraitAssocConstId: TypeFoldable<I>, <I as Interner>::InherentAssocConstId: TypeFoldable<I>, <I as Interner>::FreeConstAliasId: TypeFoldable<I>, <I as Interner>::AnonConstId: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<AliasConstKind<I>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> AliasConstKind<I>

where __F: TypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<I> TypeVisitable<I> for AliasConstKind<I>

where I: Interner, <I as Interner>::TraitAssocConstId: TypeVisitable<I>, <I as Interner>::InherentAssocConstId: TypeVisitable<I>, <I as Interner>::FreeConstAliasId: TypeVisitable<I>, <I as Interner>::AnonConstId: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

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.