Struct BestObligation

struct BestObligation<'tcx> {
    obligation: PredicateObligation<'tcx>,
    consider_ambiguities: bool,
}

Fields

obligation: PredicateObligation<'tcx>

consider_ambiguities: bool

Implementations

impl<'tcx> BestObligation<'tcx>

fn with_derived_obligation( &mut self, derived_obligation: PredicateObligation<'tcx>, and_then: impl FnOnce(&mut Self) -> ControlFlow<Obligation<'tcx, Predicate<'tcx>>>, ) -> ControlFlow<Obligation<'tcx, Predicate<'tcx>>>

fn non_trivial_candidates<'a>( &self, goal: &'a InspectGoal<'a, 'tcx>, ) -> Vec<InspectCandidate<'a, 'tcx>>

Filter out the candidates that aren’t interesting to visit for the purposes of reporting errors. For ambiguities, we only consider candidates that may hold. For errors, we only consider candidates that don’t hold and which have impl-where clauses that also don’t hold.

fn visit_well_formed_goal( &mut self, candidate: &InspectCandidate<'_, 'tcx>, term: Term<'tcx>, ) -> ControlFlow<PredicateObligation<'tcx>>

HACK: We walk the nested obligations for a well-formed arg manually, since there’s nontrivial logic in wf.rs to set up an obligation cause. Ideally we’d be able to track this better.

fn detect_error_in_self_ty_normalization( &mut self, goal: &InspectGoal<'_, 'tcx>, self_ty: Ty<'tcx>, ) -> ControlFlow<PredicateObligation<'tcx>>

If a normalization of an associated item or a trait goal fails without trying any candidates it’s likely that normalizing its self type failed. We manually detect such cases here.

fn detect_trait_error_in_higher_ranked_projection( &mut self, goal: &InspectGoal<'_, 'tcx>, ) -> ControlFlow<PredicateObligation<'tcx>>

When a higher-ranked projection goal fails, check that the corresponding higher-ranked trait goal holds or not. This is because the process of instantiating and then re-canonicalizing the binder of the projection goal forces us to be unable to see that the leak check failed in the nested NormalizesTo goal, so we don’t fall back to the rigid projection check that should catch when a projection goal fails due to an unsatisfied trait goal.

fn detect_non_well_formed_assoc_item( &mut self, goal: &InspectGoal<'_, 'tcx>, alias: AliasTerm<'tcx>, ) -> ControlFlow<PredicateObligation<'tcx>>

It is likely that NormalizesTo failed without any applicable candidates because the alias is not well-formed.

As we only enter RigidAlias candidates if the trait bound of the associated type holds, we discard these candidates in non_trivial_candidates and always manually check this here.

fn detect_error_from_empty_candidates( &mut self, goal: &InspectGoal<'_, 'tcx>, ) -> ControlFlow<PredicateObligation<'tcx>>

If we have no candidates, then it’s likely that there is a non-well-formed alias in the goal.

Trait Implementations

impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx>

type Result = ControlFlow<Obligation<'tcx, Predicate<'tcx>>>

fn span(&self) -> Span

fn visit_goal(&mut self, goal: &InspectGoal<'_, 'tcx>) -> Self::Result

fn config(&self) -> InspectConfig

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