rustc_next_trait_solver::solve::eval_ctxt

Struct ReplaceAliasWithInfer

struct ReplaceAliasWithInfer<'me, 'a, D, I>where
    D: SolverDelegate<Interner = I>,
    I: Interner,{
    ecx: &'me mut EvalCtxt<'a, D>,
    param_env: I::ParamEnv,
    cache: HashMap<I::Ty, I::Ty>,
}

Expand description

Eagerly replace aliases with inference variables, emitting AliasRelate goals, used when adding goals to the EvalCtxt. We compute the AliasRelate goals before evaluating the actual goal to get all the constraints we can.

This is a performance optimization to more eagerly detect cycles during trait solving. See tests/ui/traits/next-solver/cycles/cycle-modulo-ambig-aliases.rs.

Fields§

§ecx: &'me mut EvalCtxt<'a, D>§param_env: I::ParamEnv§cache: HashMap<I::Ty, I::Ty>

Struct ReplaceAliasWithInferCopy item path

Fields§

Implementations§

impl<'me, 'a, D, I> ReplaceAliasWithInfer<'me, 'a, D, I>where D: SolverDelegate<Interner = I>, I: Interner,

fn new(ecx: &'me mut EvalCtxt<'a, D>, param_env: I::ParamEnv) -> Self

Trait Implementations§

impl<D, I> TypeFolder<I> for ReplaceAliasWithInfer<'_, '_, D, I>where D: SolverDelegate<Interner = I>, I: Interner,

fn cx(&self) -> I

fn fold_ty(&mut self, ty: I::Ty) -> I::Ty

fn fold_const(&mut self, ct: I::Const) -> I::Const

fn fold_predicate(&mut self, predicate: I::Predicate) -> I::Predicate

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

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

Auto Trait Implementations§

impl<'me, 'a, D, I> Freeze for ReplaceAliasWithInfer<'me, 'a, D, I>where <I as Interner>::ParamEnv: Freeze,

impl<'me, 'a, D, I> Unpin for ReplaceAliasWithInfer<'me, 'a, D, I>where <I as Interner>::ParamEnv: Unpin, <I as Interner>::Ty: Unpin,

impl<'me, 'a, D, I> !UnwindSafe for ReplaceAliasWithInfer<'me, 'a, D, I>

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

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

fn with_current_subscriber(self) -> WithDispatch<Self>

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

Layout§

Struct ReplaceAliasWithInfer

impl<'me, 'a, D, I> ReplaceAliasWithInfer<'me, 'a, D, I>
where D: SolverDelegate<Interner = I>, I: Interner,

impl<D, I> TypeFolder<I> for ReplaceAliasWithInfer<'_, '_, D, I>
where D: SolverDelegate<Interner = I>, I: Interner,

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

impl<'me, 'a, D, I> Freeze for ReplaceAliasWithInfer<'me, 'a, D, I>
where <I as Interner>::ParamEnv: Freeze,

impl<'me, 'a, D, I> Unpin for ReplaceAliasWithInfer<'me, 'a, D, I>
where <I as Interner>::ParamEnv: Unpin, <I as Interner>::Ty: Unpin,

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

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

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