Enum BoundVarIndexKind 

pub enum BoundVarIndexKind {
    Bound(DebruijnIndex),
    Canonical,
}

Okay, we do something fun for Bound types/regions/consts: Specifically, we distinguish between canonically bound things and for<> bound things. And, really, it comes down to caching during canonicalization and instantiation.

To understand why we do this, imagine we have a type (T, for<> fn(T)). If we just tracked canonically bound types with a DebruijnIndex (as we used to), then the canonicalized type would be something like for<0> (^0.0, for<> fn(^1.0)) and so we can’t cache T -> ^0.0, we have to also factor in binder level. (Of course, we don’t cache that exactly, but rather the entire enclosing type, but the point stands.)

Of course, this is okay because we don’t ever nest canonicalization, so BoundVarIndexKind::Canonical is unambiguous. We, alternatively, could have some sentinel DebruijinIndex, but that just seems too scary.

This doesn’t seem to have a huge perf swing either way, but in the next solver, canonicalization is hot and there are some pathological cases where this is needed (post-mono-higher-ranked-hang).

Variants

Bound(DebruijnIndex)

Canonical

Trait Implementations

impl Clone for BoundVarIndexKind

fn clone(&self) -> BoundVarIndexKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoundVarIndexKind

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

Formats the value using the given formatter.

impl<__D> Decodable<__D> for BoundVarIndexKind

where __D: Decoder,

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

impl<__E> Encodable<__E> for BoundVarIndexKind

where __E: Encoder,

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

impl Hash for BoundVarIndexKind

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<__CTX> HashStable<__CTX> for BoundVarIndexKind

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl PartialEq for BoundVarIndexKind

fn eq(&self, other: &BoundVarIndexKind) -> 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> TypeFoldable<I> for BoundVarIndexKind

where I: Interner,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<BoundVarIndexKind, <__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) -> BoundVarIndexKind

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 BoundVarIndexKind

where I: Interner,

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

impl Copy for BoundVarIndexKind

impl Eq for BoundVarIndexKind

impl StructuralPartialEq for BoundVarIndexKind

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 4 bytes

Size for each variant:

• Bound: 4 bytes
• Canonical: 0 bytes