Struct rustc_trait_selection::solve::eval_ctxt::ReplaceAliasWithInfer

source ·

struct ReplaceAliasWithInfer<'me, 'a, 'tcx> {
    ecx: &'me mut EvalCtxt<'a, InferCtxt<'tcx>>,
    param_env: ParamEnv<'tcx>,
}

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, InferCtxt<'tcx>>§param_env: ParamEnv<'tcx>

Struct rustc_trait_selection::solve::eval_ctxt::ReplaceAliasWithInferCopy item path

Fields§

Trait Implementations§

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceAliasWithInfer<'_, '_, 'tcx>

fn interner(&self) -> TyCtxt<'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_region(&mut self, r: <I as Interner>::Region) -> <I as Interner>::Region

Auto Trait Implementations§

impl<'me, 'a, 'tcx> !DynSend for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> !DynSync for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> Freeze for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> !RefUnwindSafe for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> !Send for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> !Sync for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> Unpin for ReplaceAliasWithInfer<'me, 'a, 'tcx>

impl<'me, 'a, 'tcx> !UnwindSafe for ReplaceAliasWithInfer<'me, '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 interner(&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>,

fn vzip(self) -> V

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

default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

Struct rustc_trait_selection::solve::eval_ctxt::ReplaceAliasWithInfer

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,