Struct PredicateSearcher 

pub struct PredicateSearcher<'tcx> {
    tcx: TyCtxt<'tcx>,
    typing_env: TypingEnv<'tcx>,
    candidates: HashMap<PolyTraitPredicate<'tcx>, Candidate<'tcx>>,
    options: BoundsOptions,
    bound_clause_count: usize,
}

Stores a set of predicates along with where they came from.

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

candidates: HashMap<PolyTraitPredicate<'tcx>, Candidate<'tcx>>

Local clauses available in the current context.

options: BoundsOptions

Resolution options.

bound_clause_count: usize

Count the number of bound clauses in scope; used to identify clauses uniquely.

Implementations

impl<'tcx> PredicateSearcher<'tcx>

pub fn new_for_owner( tcx: TyCtxt<'tcx>, owner_id: DefId, options: BoundsOptions, ) -> Self

Initialize the elaborator with the predicates accessible within this item.

pub fn insert_bound_predicates( &mut self, clauses: impl IntoIterator<Item = PolyTraitPredicate<'tcx>>, )

Insert the bound clauses in the search context. Prefer inserting them all at once as this will give priority to shorter resolution paths. Bound clauses are numbered from 0 in insertion order.

pub fn set_param_env(&mut self, param_env: ParamEnv<'tcx>)

Override the param env; we use this when resolving dyn predicates to add more clauses to the scope.

fn insert_predicates( &mut self, preds: impl IntoIterator<Item = AnnotatedTraitPred<'tcx>>, )

Insert annotated predicates in the search context. Prefer inserting them all at once as this will give priority to shorter resolution paths.

fn insert_candidates( &mut self, candidates: impl IntoIterator<Item = Candidate<'tcx>>, )

Insert new candidates and all their parent predicates. This deduplicates predicates to avoid divergence.

fn insert_candidate_parents(&mut self, new_candidates: Vec<Candidate<'tcx>>)

Add the parents of these candidates. This is a separate function to avoid polymorphic recursion due to the closures capturing the type parameters of this function.

fn add_associated_type_refs( &mut self, ty: Binder<'tcx, Ty<'tcx>>, warn: &impl Fn(&str), ) -> Result<(), String>

If the type is a trait associated type, we add any relevant bounds to our context.

fn resolve_local( &mut self, target: PolyTraitPredicate<'tcx>, warn: &impl Fn(&str), ) -> Result<Option<Candidate<'tcx>>, String>

Resolve a local clause by looking it up in this set. If the predicate applies to an associated type, we add the relevant implied associated type bounds to the set as well.

pub fn resolve( &mut self, tref: &PolyTraitRef<'tcx>, warn: &impl Fn(&str), ) -> Result<ImplExpr<'tcx>, String>

Resolve the given trait reference in the local context.

pub fn resolve_item_required_predicates( &mut self, def_id: DefId, generics: GenericArgsRef<'tcx>, warn: &impl Fn(&str), ) -> Result<Vec<ImplExpr<'tcx>>, String>

Resolve the predicates required by the given item.

pub fn resolve_item_implied_predicates( &mut self, def_id: DefId, generics: GenericArgsRef<'tcx>, warn: &impl Fn(&str), ) -> Result<Vec<ImplExpr<'tcx>>, String>

Resolve the predicates implied by the given item.

pub fn resolve_predicates( &mut self, generics: GenericArgsRef<'tcx>, predicates: Predicates<'tcx>, warn: &impl Fn(&str), ) -> Result<Vec<ImplExpr<'tcx>>, String>

Apply the given generics to the provided clauses and resolve the trait references in the current context.

Trait Implementations

impl<'tcx> Clone for PredicateSearcher<'tcx>

fn clone(&self) -> PredicateSearcher<'tcx>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.