Enum TreatParams

pub enum TreatParams {
    InstantiateWithInfer,
    AsRigid,
}

Generic parameters are pretty much just bound variables, e.g. the type of fn foo<'a, T>(x: &'a T) -> u32 { ... } can be thought of as for<'a, T> fn(&'a T) -> u32.

Typecheck of foo has to succeed for all possible generic arguments, so during typeck, we have to treat its generic parameters as if they were placeholders.

But when calling foo we only have to provide a specific generic argument. In that case the generic parameters are instantiated with inference variables. As we use simplify_type before that instantiation happens, we just treat generic parameters as if they were inference variables in that case.

Variants

InstantiateWithInfer

Treat parameters as infer vars. This is the correct mode for caching an impl’s type for lookup.

AsRigid

Treat parameters as placeholders in the given environment. This is the correct mode for lookup, as during candidate selection.

This also treats projections with inference variables as infer vars since they could be further normalized.

Trait Implementations

impl Clone for TreatParams

fn clone(&self) -> TreatParams

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TreatParams

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

Formats the value using the given formatter.

impl PartialEq for TreatParams

fn eq(&self, other: &TreatParams) -> 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 Copy for TreatParams

impl Eq for TreatParams

impl StructuralPartialEq for TreatParams

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: 1 byte

Size for each variant:

• InstantiateWithInfer: 0 bytes
• AsRigid: 0 bytes