Struct rustc_trait_selection::solve::inspect::build::ProofTreeBuilder

pub(in solve) struct ProofTreeBuilder<'tcx> {
    state: Option<Box<DebugSolver<'tcx>>>,
}

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

state: Option<Box<DebugSolver<'tcx>>>

Implementations

impl<'tcx> ProofTreeBuilder<'tcx>

pub fn make_canonical_state<T: TypeFoldable<TyCtxt<'tcx>>>( ecx: &EvalCtxt<'_, 'tcx>, data: T ) -> CanonicalState<'tcx, T>

pub fn instantiate_canonical_state<T: TypeFoldable<TyCtxt<'tcx>>>( infcx: &InferCtxt<'tcx>, param_env: ParamEnv<'tcx>, original_values: &[GenericArg<'tcx>], state: CanonicalState<'tcx, T> ) -> T

Instantiate a CanonicalState. This assumes that unifying the var values trivially succeeds. Adding any inference constraints which weren’t present when originally computing the canonical query can result in bugs.

impl<'tcx> ProofTreeBuilder<'tcx>

fn new(state: impl Into<DebugSolver<'tcx>>) -> ProofTreeBuilder<'tcx>

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

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

pub fn finalize(self) -> Option<GoalEvaluation<'tcx>>

pub fn new_maybe_root( tcx: TyCtxt<'tcx>, generate_proof_tree: GenerateProofTree ) -> ProofTreeBuilder<'tcx>

pub fn new_root() -> ProofTreeBuilder<'tcx>

pub fn new_noop() -> ProofTreeBuilder<'tcx>

pub fn is_noop(&self) -> bool

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

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

pub fn finalize_evaluation( &mut self, tcx: TyCtxt<'tcx> ) -> Option<&'tcx [GoalEvaluationStep<'tcx>]>

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

pub fn goal_evaluation_kind( &mut self, kind: WipCanonicalGoalEvaluationKind<'tcx> )

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

pub fn new_goal_evaluation_step( &mut self, instantiated_goal: QueryInput<'tcx, Predicate<'tcx>> ) -> ProofTreeBuilder<'tcx>

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

pub fn new_probe(&mut self) -> ProofTreeBuilder<'tcx>

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

pub fn add_goal( ecx: &mut EvalCtxt<'_, 'tcx>, source: GoalSource, goal: Goal<'tcx, Predicate<'tcx>> )

pub fn finish_probe(&mut self, probe: ProofTreeBuilder<'tcx>)

pub fn integrate_snapshot(&mut self, probe: ProofTreeBuilder<'tcx>)

Used by EvalCtxt::commit_if_ok to flatten the work done inside of the probe into the parent.

pub fn new_evaluate_added_goals(&mut self) -> ProofTreeBuilder<'tcx>

pub fn evaluate_added_goals_loop_start(&mut self)

pub fn eval_added_goals_result(&mut self, result: Result<Certainty, NoSolution>)

pub fn added_goals_evaluation( &mut self, added_goals_evaluation: ProofTreeBuilder<'tcx> )

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

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