Struct Resolver 

struct Resolver<'cx, 'tcx> {
    fcx: &'cx FnCtxt<'cx, 'tcx>,
    span: &'cx dyn Locatable,
    body: &'tcx Body<'tcx>,
    should_normalize: bool,
    nested_goals: &'cx mut Vec<Goal<'tcx, Predicate<'tcx>>>,
}

Fields

fcx: &'cx FnCtxt<'cx, 'tcx>

span: &'cx dyn Locatable

body: &'tcx Body<'tcx>

should_normalize: bool

Whether we should normalize using the new solver, disabled both when using the old solver and when resolving predicates.

nested_goals: &'cx mut Vec<Goal<'tcx, Predicate<'tcx>>>

Implementations

impl<'cx, 'tcx> Resolver<'cx, 'tcx>

fn new( fcx: &'cx FnCtxt<'cx, 'tcx>, span: &'cx dyn Locatable, body: &'tcx Body<'tcx>, should_normalize: bool, nested_goals: &'cx mut Vec<Goal<'tcx, Predicate<'tcx>>>, ) -> Resolver<'cx, 'tcx>

fn report_error(&self, p: impl Into<Term<'tcx>>) -> ErrorGuaranteed

fn handle_term<T>( &mut self, value: T, outer_exclusive_binder: impl FnOnce(T) -> DebruijnIndex, new_err: impl Fn(TyCtxt<'tcx>, ErrorGuaranteed) -> T, ) -> T

where T: Into<Term<'tcx>> + TypeSuperFoldable<TyCtxt<'tcx>> + Copy,

Trait Implementations

impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx>

fn cx(&self) -> TyCtxt<'tcx>

fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx>

fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx>

fn fold_const(&mut self, ct: Const<'tcx>) -> Const<'tcx>

fn fold_predicate(&mut self, predicate: Predicate<'tcx>) -> Predicate<'tcx>

fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>

where T: TypeFoldable<I>,

fn fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> <I as Interner>::Clauses

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