Struct rustc_trait_selection::infer::resolve::OpportunisticRegionResolver

source ·

pub struct OpportunisticRegionResolver<'a, 'tcx> {
    infcx: &'a InferCtxt<'tcx>,
}

Expand description

The opportunistic region resolver opportunistically resolves regions variables to the variable with the least variable id. It is used when normalizing projections to avoid hitting the recursion limit by creating many versions of a predicate for types that in the end have to unify.

If you want to resolve type and const variables as well, call InferCtxt::resolve_vars_if_possible first.

Fields§

§infcx: &'a InferCtxt<'tcx>

Auto Trait Implementations§

§

Struct rustc_trait_selection::infer::resolve::OpportunisticRegionResolver

Fields§

Auto Trait Implementations§

impl<'a, 'tcx> !RefUnwindSafe for OpportunisticRegionResolver<'a, 'tcx>

impl<'a, 'tcx> !Send for OpportunisticRegionResolver<'a, 'tcx>

impl<'a, 'tcx> !Sync for OpportunisticRegionResolver<'a, 'tcx>

impl<'a, 'tcx> Unpin for OpportunisticRegionResolver<'a, 'tcx>

impl<'a, 'tcx> !UnwindSafe for OpportunisticRegionResolver<'a, 'tcx>

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<I, F> FallibleTypeFolder<I> for Fwhere I: Interner, F: TypeFolder<I>,

type Error = !

fn interner(&self) -> I

fn try_fold_binder<T>( &mut self, t: <I as Interner>::Binder<T> ) -> Result<<I as Interner>::Binder<T>, !>where T: TypeFoldable<I>, <I as Interner>::Binder<T>: TypeSuperFoldable<I>,

fn try_fold_ty( &mut self, t: <I as Interner>::Ty ) -> Result<<I as Interner>::Ty, !>where <I as Interner>::Ty: TypeSuperFoldable<I>,

fn try_fold_region( &mut self, r: <I as Interner>::Region ) -> Result<<I as Interner>::Region, !>

fn try_fold_const( &mut self, c: <I as Interner>::Const ) -> Result<<I as Interner>::Const, !>where <I as Interner>::Const: TypeSuperFoldable<I>,

fn try_fold_predicate( &mut self, p: <I as Interner>::Predicate ) -> Result<<I as Interner>::Predicate, !>where <I as Interner>::Predicate: TypeSuperFoldable<I>,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Layout§