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(crate) fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<D>

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

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

fn new_root() -> ProofTreeBuilder<D>

fn new_noop() -> ProofTreeBuilder<D>

pub(crate) 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(crate) fn new_canonical_goal_evaluation( &mut self, goal: CanonicalInput<I>, ) -> ProofTreeBuilder<D>

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

pub(crate) fn canonical_goal_evaluation_overflow(&mut self)

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

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

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

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

fn enter_probe(&mut self)

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

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

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

pub(crate) 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(crate) fn make_canonical_response(&mut self, shallow_certainty: Certainty)

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

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

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