Struct 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>

Struct OpportunisticRegionResolverCopy item path

Fields§

Implementations§

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

pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self

Trait Implementations§

impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for OpportunisticRegionResolver<'a, 'tcx>

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

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

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

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

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

fn fold_predicate( &mut self, p: <I as Interner>::Predicate, ) -> <I as Interner>::Predicate

Auto Trait Implementations§

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

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

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

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> Aligned for T

const ALIGN: Alignment = _

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<T, R> CollectAndApply<T, R> for T

fn collect_and_apply<I, F>(iter: I, f: F) -> Rwhere I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

type Output = R

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

type Error = !

fn cx(&self) -> I

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

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

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, !>

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

impl<T> Filterable for T

fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

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

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<P> IntoQueryParam<P> for P

fn into_query_param(self) -> P

impl<T> MaybeResult<T> for T

type Error = !

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

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>

impl<I, T, U> Upcast<I, U> for Twhere U: UpcastFrom<I, T>,

fn upcast(self, interner: I) -> U

impl<I, T> UpcastFrom<I, T> for T

fn upcast_from(from: T, _tcx: I) -> T

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

Struct OpportunisticRegionResolver

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

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

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

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

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

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

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

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

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

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

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

impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<'a, T> Captures<'a> for T
where T: ?Sized,

impl<T> ErasedDestructor for T
where T: 'static,