Enum TypingMode 

pub enum TypingMode<I>
where
    I: Interner,
{
    Coherence,
    Analysis {
        defining_opaque_types_and_generators: <I as Interner>::LocalDefIds,
    },
    Borrowck {
        defining_opaque_types: <I as Interner>::LocalDefIds,
    },
    PostBorrowckAnalysis {
        defined_opaque_types: <I as Interner>::LocalDefIds,
    },
    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 automatically 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.

Because typing rules get subtly different based on what typing mode we’re in, subtle enough that changing the behavior of typing modes can sometimes cause changes that we don’t even have tests for, we’d like to enforce the rule that any place where we specialize behavior based on the typing mode, we match exhaustively on the typing mode. That way, it’s easy to determine all the places that must change when anything about typing modes changes.

Hence, TypingMode does not implement Eq, though TypingModeEqWrapper is available in the rare case that you do need this. Most cases where this currently matters is where we pass typing modes through the query system and want to cache based on it. See also #[rustc_must_match_exhaustively], which tries to detect non-exhaustive matches.

Since matching on typing mode to single out Coherence is so common, and Coherence is so different from the other modes: see also is_coherence

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.

We also refuse to project any associated type that is marked default. Non-default (“final”) types are always projected. This is necessary in general for soundness of specialization. However, we could allow projections in fully-monomorphic cases. We choose not to, because we prefer for default type to force the type definition to be treated abstractly by any consumers of the impl. Concretely, that means that the following example will fail to compile:

#![feature(specialization)]
trait Assoc {
    type Output;
}

impl<T> Assoc for T {
    default type Output = bool;
}

fn main() {
    let x: <() as Assoc>::Output = true;
}

Fields

defining_opaque_types_and_generators: <I as Interner>::LocalDefIds

Borrowck

The behavior during MIR borrowck is identical to TypingMode::Analysis except that the initial value for opaque types is the type computed during HIR typeck with unique unconstrained region inference variables.

This is currently only used with by the new solver as it results in new non-universal defining uses of opaque types, which is a breaking change. See tests/ui/impl-trait/non-defining-use/as-projection-term.rs.

Fields

defining_opaque_types: <I as Interner>::LocalDefIds

PostBorrowckAnalysis

Any analysis after borrowck for a given body should be able to use all the hidden types defined by borrowck, without being able to define any new ones.

This is currently only used by the new solver, but should be implemented in the old solver as well.

Fields

defined_opaque_types: <I as Interner>::LocalDefIds

PostAnalysis

After analysis, mostly during codegen and MIR optimizations, we’re able to reveal all opaque types. As the hidden type should never be observable directly by the user, this should not be used by checks which may expose such details to the user.

There are some exceptions to this as for example layout_of and const-evaluation always run in PostAnalysis mode, even when used during analysis. This exposes some information about the underlying type to users, but not the type itself.

Implementations

impl<I> TypingMode<I>

where I: Interner,

pub fn is_coherence(&self) -> bool

There are a bunch of places in the compiler where we single out Coherence, and alter behavior. We’d like to always match on TypingMode exhaustively, but not having this method leads to a bunch of noisy code.

See also the documentation on TypingMode about exhaustive matching.

pub fn non_body_analysis() -> TypingMode<I>

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

pub fn typeck_for_body( cx: I, body_def_id: <I as Interner>::LocalDefId, ) -> TypingMode<I>

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

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

FIXME: This will be removed because it’s generally not correct to define opaques outside of HIR typeck.

pub fn borrowck( cx: I, body_def_id: <I as Interner>::LocalDefId, ) -> TypingMode<I>

pub fn post_borrowck_analysis( cx: I, body_def_id: <I as Interner>::LocalDefId, ) -> TypingMode<I>

Trait Implementations

impl<I> Clone for TypingMode<I>

where I: Interner,

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

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl<I, __D> Decodable<__D> for TypingMode<I>

where I: Interner, __D: Decoder, <I as Interner>::LocalDefIds: Decodable<__D>,

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

impl<I, __E> Encodable<__E> for TypingMode<I>

where I: Interner, __E: Encoder, <I as Interner>::LocalDefIds: Encodable<__E>,

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

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

where I: Interner, <I as Interner>::LocalDefIds: HashStable<__CTX>,

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

impl<I> Copy 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.