Struct rustc_next_trait_solver::solve::inspect::build::ProofTreeBuilder
source · pub(crate) struct ProofTreeBuilder<D, I = I>where
D: SolverDelegate<Interner = I>,
I: Interner,{
_infcx: PhantomData<D>,
state: Option<Box<DebugSolver<I>>>,
}
Expand description
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§
source§impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D>
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>)
Auto Trait Implementations§
impl<D, I> DynSend for ProofTreeBuilder<D, I>where
<D as Deref>::Target: Sized,
D: DynSend,
<I as Interner>::ParamEnv: DynSend,
<I as Interner>::Predicate: DynSend,
<I as Interner>::GenericArg: DynSend,
<I as Interner>::DefiningOpaqueTypes: DynSend,
<I as Interner>::CanonicalVars: DynSend,
<I as Interner>::PredefinedOpaques: DynSend,
<I as Interner>::ExternalConstraints: DynSend,
<I as Interner>::DefId: DynSend,
<I as Interner>::GenericArgs: DynSend,
impl<D, I> DynSync for ProofTreeBuilder<D, I>where
<D as Deref>::Target: Sized,
D: DynSync,
<I as Interner>::ParamEnv: DynSync,
<I as Interner>::Predicate: DynSync,
<I as Interner>::GenericArg: DynSync,
<I as Interner>::DefiningOpaqueTypes: DynSync,
<I as Interner>::CanonicalVars: DynSync,
<I as Interner>::PredefinedOpaques: DynSync,
<I as Interner>::ExternalConstraints: DynSync,
<I as Interner>::DefId: DynSync,
<I as Interner>::GenericArgs: DynSync,
impl<D, I> Freeze for ProofTreeBuilder<D, I>
impl<D, I> RefUnwindSafe for ProofTreeBuilder<D, I>where
<D as Deref>::Target: Sized,
D: RefUnwindSafe,
<I as Interner>::ParamEnv: RefUnwindSafe,
<I as Interner>::Predicate: RefUnwindSafe,
<I as Interner>::DefiningOpaqueTypes: RefUnwindSafe,
<I as Interner>::CanonicalVars: RefUnwindSafe,
<I as Interner>::PredefinedOpaques: RefUnwindSafe,
<I as Interner>::GenericArg: RefUnwindSafe,
<I as Interner>::ExternalConstraints: RefUnwindSafe,
<I as Interner>::DefId: RefUnwindSafe,
<I as Interner>::GenericArgs: RefUnwindSafe,
impl<D, I> Send for ProofTreeBuilder<D, I>where
<D as Deref>::Target: Sized,
D: Send,
<I as Interner>::ParamEnv: Send,
<I as Interner>::Predicate: Send,
<I as Interner>::DefiningOpaqueTypes: Send,
<I as Interner>::CanonicalVars: Send,
<I as Interner>::PredefinedOpaques: Send,
<I as Interner>::GenericArg: Send,
<I as Interner>::ExternalConstraints: Send,
<I as Interner>::DefId: Send,
<I as Interner>::GenericArgs: Send,
impl<D, I> Sync for ProofTreeBuilder<D, I>where
<D as Deref>::Target: Sized,
D: Sync,
<I as Interner>::ParamEnv: Sync,
<I as Interner>::Predicate: Sync,
<I as Interner>::DefiningOpaqueTypes: Sync,
<I as Interner>::CanonicalVars: Sync,
<I as Interner>::PredefinedOpaques: Sync,
<I as Interner>::GenericArg: Sync,
<I as Interner>::ExternalConstraints: Sync,
<I as Interner>::DefId: Sync,
<I as Interner>::GenericArgs: Sync,
impl<D, I> Unpin for ProofTreeBuilder<D, I>
impl<D, I> UnwindSafe for ProofTreeBuilder<D, I>where
<D as Deref>::Target: Sized,
D: UnwindSafe,
<I as Interner>::ParamEnv: UnwindSafe,
<I as Interner>::Predicate: UnwindSafe,
<I as Interner>::DefiningOpaqueTypes: UnwindSafe,
<I as Interner>::CanonicalVars: UnwindSafe,
<I as Interner>::PredefinedOpaques: UnwindSafe,
<I as Interner>::GenericArg: UnwindSafe,
<I as Interner>::ExternalConstraints: UnwindSafe,
<I as Interner>::DefId: UnwindSafe,
<I as Interner>::GenericArgs: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
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