Enum CanonicalVarKind

pub enum CanonicalVarKind<I: Interner> {
    Ty(CanonicalTyVarKind),
    PlaceholderTy(I::PlaceholderTy),
    Region(UniverseIndex),
    PlaceholderRegion(I::PlaceholderRegion),
    Const(UniverseIndex),
    PlaceholderConst(I::PlaceholderConst),
}

Information about a canonical variable that is included with the canonical value. This is sufficient information for code to create a copy of the canonical value in some other inference context, with fresh inference variables replacing the canonical values.

Variants

Ty(CanonicalTyVarKind)

Some kind of type inference variable.

PlaceholderTy(I::PlaceholderTy)

A “placeholder” that represents “any type”.

Region(UniverseIndex)

Region variable '?R.

PlaceholderRegion(I::PlaceholderRegion)

A “placeholder” that represents “any region”. Created when you are solving a goal like for<'a> T: Foo<'a> to represent the bound region 'a.

Const(UniverseIndex)

Some kind of const inference variable.

PlaceholderConst(I::PlaceholderConst)

A “placeholder” that represents “any const”.

Implementations

impl<I: Interner> CanonicalVarKind<I>

pub fn universe(self) -> UniverseIndex

pub fn with_updated_universe(self, ui: UniverseIndex) -> CanonicalVarKind<I>

Replaces the universe of this canonical variable with ui.

In case this is a float or int variable, this causes an ICE if the updated universe is not the root.

pub fn is_existential(self) -> bool

pub fn is_region(self) -> bool

pub fn expect_placeholder_index(self) -> usize

Trait Implementations

impl<I> Clone for CanonicalVarKind<I>

where I: Interner,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for CanonicalVarKind<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 CanonicalVarKind<I>

where I::PlaceholderTy: Decodable<__D>, I::PlaceholderRegion: Decodable<__D>, I::PlaceholderConst: Decodable<__D>,

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

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

where I::PlaceholderTy: Encodable<__E>, I::PlaceholderRegion: Encodable<__E>, I::PlaceholderConst: Encodable<__E>,

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

impl<I> Hash for CanonicalVarKind<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: Interner, __CTX> HashStable<__CTX> for CanonicalVarKind<I>

where I::PlaceholderTy: HashStable<__CTX>, I::PlaceholderRegion: HashStable<__CTX>, I::PlaceholderConst: HashStable<__CTX>,

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

impl<I> PartialEq for CanonicalVarKind<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> Copy for CanonicalVarKind<I>

where I: Interner,

impl<I> Eq for CanonicalVarKind<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.