Struct StackEntry 

pub(super) struct StackEntry<X: Cx> {
    pub input: X::Input,
    pub step_kind_from_parent: PathKind,
    pub available_depth: AvailableDepth,
    pub min_reached_available_depth: AvailableDepth,
    pub increase_depth_for_nested: IncreaseDepthForNested,
    pub provisional_result: Option<X::Result>,
    pub heads: CycleHeads,
    pub encountered_overflow: bool,
    pub usages: Option<HeadUsages>,
    pub candidate_usages: Option<CandidateHeadUsages>,
    pub nested_goals: NestedGoals<X>,
}

Stack entries of the evaluation stack. Its fields tend to be lazily updated when popping a child goal or completely immutable.

Fields

input: X::Input

step_kind_from_parent: PathKind

Whether proving this goal is a coinductive step.

This is used when encountering a trait solver cycle to decide whether the initial provisional result of the cycle.

available_depth: AvailableDepth

The available depth of a given goal, immutable.

min_reached_available_depth: AvailableDepth

The minimum available depth encountered while evaluating this goal’s nested goals. If there’s no nested goal, this is equal to the available_depth.

increase_depth_for_nested: IncreaseDepthForNested

Whether evaluating nested goals of a given goal should increase the depth.

Normally, it should be Yes, but among rustc’s predicate goals, normalizes-to goals are exceptions. They act like functions that used for normalizing associated terms while evaluating projection goals and since their expected terms are always fully unconstrained intentionally, they often return ambiguous nested goals to the caller’s context. As these nested goals are evaluated again in the caller’s context, we don’t want to increase depths when they are evaluated as nested goals for normalizes-to goals, otherwise we will encounter recursion limit overflows more often.

provisional_result: Option<X::Result>

Starts out as None and gets set when rerunning this goal in case we encounter a cycle.

heads: CycleHeads

All cycle heads this goal depends on. Lazily updated and only up-to date for the top of the stack.

encountered_overflow: bool

Whether evaluating this goal encountered overflow. Lazily updated.

usages: Option<HeadUsages>

Whether and how this goal has been used as a cycle head. Lazily updated.

candidate_usages: Option<CandidateHeadUsages>

We want to be able to ignore head usages if they happen inside of candidates which don’t impact the result of a goal. This enables us to avoid rerunning goals and is also used when rebasing provisional cache entries.

To implement this, we track all usages while evaluating a candidate. If this candidate then ends up ignored, we manually remove its usages from usages and heads.

nested_goals: NestedGoals<X>

The nested goals of this goal, see the doc comment of the type.

Implementations

impl<X: Cx> StackEntry<X>

pub(super) fn required_depth(&self) -> usize

Trait Implementations

impl<X> Debug for StackEntry<X>

where X: Cx,

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

Formats the value using the given formatter.

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.