Enum TypingMode

pub enum TypingMode<I: Interner> {
    Coherence,
    Analysis {
        defining_opaque_types: I::DefiningOpaqueTypes,
    },
    PostAnalysis,
}

The current typing mode of an inference context. We unfortunately have some slightly different typing rules depending on the current context. See the doc comment for each variant for how and why they are used.

In most cases you can get the correct typing mode automically via:

• mir::Body::typing_mode
• rustc_lint::LateContext::typing_mode

If neither of these functions are available, feel free to reach out to t-types for help.

Variants

Coherence

When checking whether impls overlap, we check whether any obligations are guaranteed to never hold when unifying the impls. This requires us to be complete: we must never fail to prove something which may actually hold.

In this typing mode we bail with ambiguity in case its not knowable whether a trait goal may hold, e.g. because the trait may get implemented in a downstream or sibling crate.

We also have to be careful when generalizing aliases inside of higher-ranked types to not unnecessarily constrain any inference variables.

Analysis

Analysis includes type inference, checking that items are well-formed, and pretty much everything else which may emit proper type errors to the user.

We only normalize opaque types which may get defined by the current body, which are stored in defining_opaque_types.

Fields

defining_opaque_types: I::DefiningOpaqueTypes

PostAnalysis

After analysis, mostly during codegen and MIR optimizations, we’re able to reveal all opaque types.

Implementations

impl<I: Interner> TypingMode<I>

pub fn non_body_analysis() -> TypingMode<I>

Analysis outside of a body does not define any opaque types.

pub fn analysis_in_body(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I>

While typechecking a body, we need to be able to define the opaque types defined by that body.

pub fn from_param_env(param_env: I::ParamEnv) -> TypingMode<I>

FIXME(#132279): Using this function is questionable as the param_env does not track defining_opaque_types and whether we’re in coherence mode. Many uses of this function should also use a not-yet implemented typing mode which reveals already defined opaque types in the future. This function will get completely removed at some point.

Trait Implementations

impl<I> Clone for TypingMode<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 TypingMode<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I: Interner, __D: TyDecoder<I = I>> Decodable<__D> for TypingMode<I>

where I::DefiningOpaqueTypes: Decodable<__D>,

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

impl<I: Interner, __E: TyEncoder<I = I>> Encodable<__E> for TypingMode<I>

where I::DefiningOpaqueTypes: Encodable<__E>,

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

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

where I::DefiningOpaqueTypes: HashStable<__CTX>,

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

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

where I: Interner,

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