Enum rustc_infer::traits::project::ProjectionCacheEntry

pub enum ProjectionCacheEntry<'tcx> {
    InProgress,
    Ambiguous,
    Recur,
    Error,
    NormalizedTy {
        ty: Normalized<'tcx, Term<'tcx>>,
        complete: Option<EvaluationResult>,
    },
}

Variants

InProgress

Ambiguous

Recur

Error

NormalizedTy

Fields

ty: Normalized<'tcx, Term<'tcx>>

complete: Option<EvaluationResult>

If we were able to successfully evaluate the corresponding cache entry key during predicate evaluation, then this field stores the final result obtained from evaluating all of the projection sub-obligations. During evaluation, we will skip evaluating the cached sub-obligations in ty if this field is set. Evaluation only cares about the final result, so we don’t care about any region constraint side-effects produced by evaluating the sub-obligations.

Additionally, we will clear out the sub-obligations entirely if we ever evaluate the cache entry (along with all its sub obligations) to EvaluatedToOk. This affects all users of the cache, not just evaluation. Since a result of EvaluatedToOk means that there were no region obligations that need to be tracked, it’s fine to forget about the sub-obligations - they don’t provide any additional information. However, we do not discard any obligations when we see EvaluatedToOkModuloRegions - we don’t know which sub-obligations may introduce region constraints, so we keep them all to be safe.

When we are not performing evaluation (e.g. in FulfillmentContext), we ignore this field, and always re-process the cached sub-obligations (which may have been cleared out - see the above paragraph). This ensures that we do not lose any regions constraints that arise from processing the sub-obligations.

Trait Implementations

impl<'tcx> Clone for ProjectionCacheEntry<'tcx>

fn clone(&self) -> ProjectionCacheEntry<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for ProjectionCacheEntry<'tcx>

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

Formats the value using the given formatter.

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: 40 bytes

Size for each variant:

• InProgress: 0 bytes
• Ambiguous: 0 bytes
• Recur: 0 bytes
• Error: 0 bytes
• NormalizedTy: 39 bytes