Struct rustc_next_trait_solver::solve::inspect::build::ProofTreeBuilder

pub(crate) struct ProofTreeBuilder<D, I = I>
where
    D: SolverDelegate<Interner = I>,
    I: Interner,
{
    _infcx: PhantomData<D>,
    state: Option<Box<DebugSolver<I>>>,
}

The core data structure when building proof trees.

In case the current evaluation does not generate a proof tree, state is simply None and we avoid any work.

The possible states of the solver are represented via variants of DebugSolver. For any nested computation we call ProofTreeBuilder::new_nested_computation_kind which creates a new ProofTreeBuilder to temporarily replace the current one. Once that nested computation is done, ProofTreeBuilder::nested_computation_kind is called to add the finished nested evaluation to the parent.

We provide additional information to the current state by calling methods such as ProofTreeBuilder::probe_kind.

The actual structure closely mirrors the finished proof trees. At the end of trait solving ProofTreeBuilder::finalize is called to recursively convert the whole structure to a finished proof tree.

Fields

_infcx: PhantomData<D>

state: Option<Box<DebugSolver<I>>>

Implementations

impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D>

fn new(state: impl Into<DebugSolver<I>>) -> ProofTreeBuilder<D>

fn opt_nested<T: Into<DebugSolver<I>>>( &self, state: impl FnOnce() -> Option<T>, ) -> Self

fn nested<T: Into<DebugSolver<I>>>(&self, state: impl FnOnce() -> T) -> Self

fn as_mut(&mut self) -> Option<&mut DebugSolver<I>>

pub fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<D>

pub fn finalize(self) -> Option<GoalEvaluation<I>>

pub fn new_maybe_root( generate_proof_tree: GenerateProofTree, ) -> ProofTreeBuilder<D>

pub fn new_root() -> ProofTreeBuilder<D>

pub fn new_noop() -> ProofTreeBuilder<D>

pub fn is_noop(&self) -> bool

pub(in solve) fn new_goal_evaluation( &mut self, goal: Goal<I, I::Predicate>, orig_values: &[I::GenericArg], kind: GoalEvaluationKind, ) -> ProofTreeBuilder<D>

pub fn new_canonical_goal_evaluation( &mut self, goal: CanonicalInput<I>, ) -> ProofTreeBuilder<D>

pub fn canonical_goal_evaluation( &mut self, canonical_goal_evaluation: ProofTreeBuilder<D>, )

pub fn canonical_goal_evaluation_kind( &mut self, kind: WipCanonicalGoalEvaluationKind<I>, )

pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<D>)

pub fn new_goal_evaluation_step( &mut self, var_values: CanonicalVarValues<I>, instantiated_goal: QueryInput<I, I::Predicate>, ) -> ProofTreeBuilder<D>

pub fn goal_evaluation_step( &mut self, goal_evaluation_step: ProofTreeBuilder<D>, )

pub fn add_var_value<T: Into<I::GenericArg>>(&mut self, arg: T)

pub fn enter_probe(&mut self)

pub fn probe_kind(&mut self, probe_kind: ProbeKind<I>)

pub fn probe_final_state( &mut self, delegate: &D, max_input_universe: UniverseIndex, )

pub fn add_normalizes_to_goal( &mut self, delegate: &D, max_input_universe: UniverseIndex, goal: Goal<I, NormalizesTo<I>>, )

pub fn add_goal( &mut self, delegate: &D, max_input_universe: UniverseIndex, source: GoalSource, goal: Goal<I, I::Predicate>, )

pub(crate) fn record_impl_args( &mut self, delegate: &D, max_input_universe: UniverseIndex, impl_args: I::GenericArgs, )

pub fn make_canonical_response(&mut self, shallow_certainty: Certainty)

pub fn finish_probe(self) -> ProofTreeBuilder<D>

pub fn query_result(&mut self, result: QueryResult<I>)

Trait Implementations

impl<D, I> ProofTreeBuilder<I> for ProofTreeBuilder<D>

where D: SolverDelegate<Interner = I>, I: Interner,

fn try_apply_proof_tree( &mut self, proof_tree: Option<I::CanonicalGoalEvaluationStepRef>, ) -> bool

fn on_provisional_cache_hit(&mut self)

fn on_cycle_in_stack(&mut self)

fn finalize_canonical_goal_evaluation( &mut self, tcx: I, ) -> Option<I::CanonicalGoalEvaluationStepRef>

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