Struct Resolver

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

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.

Implementations

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

fn new( fcx: &'cx FnCtxt<'cx, 'tcx>, span: &'cx dyn Locatable, body: &'tcx Body<'tcx>, ) -> Resolver<'cx, 'tcx>

fn report_error(&self, p: impl Into<GenericArg<'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<GenericArg<'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>,

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