rustc_hir_analysis::collect::item_bounds

Struct MapAndCompressBoundVars

struct MapAndCompressBoundVars<'tcx> {
    tcx: TyCtxt<'tcx>,
    binder: DebruijnIndex,
    still_bound_vars: Vec<BoundVariableKind>,
    mapping: FxIndexMap<BoundVar, GenericArg<'tcx>>,
}

Expand description

Given some where clause like for<'b, 'c> <Self as Trait<'a_identity>>::Gat<'b>: Bound<'c>, the mapping will map 'b back to the GAT’s 'b_identity. Then we need to compress the remaining bound var 'c to index 0.

This folder gives us: for<'c> <Self as Trait<'a_identity>>::Gat<'b_identity>: Bound<'c>, which is sufficient for an item bound for Gat, since all of the GAT’s args are identity.

Fields§

§tcx: TyCtxt<'tcx>§binder: DebruijnIndex

How deep are we? Makes sure we don’t touch the vars of nested binders.

§still_bound_vars: Vec<BoundVariableKind>

List of bound vars that remain unsubstituted because they were not mentioned in the GAT’s args.

§mapping: FxIndexMap<BoundVar, GenericArg<'tcx>>

Subtle invariant: If the GenericArg is bound, then it should be stored with the debruijn index of INNERMOST so it can be shifted correctly during substitution.

Struct MapAndCompressBoundVarsCopy item path

Fields§

Trait Implementations§

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for MapAndCompressBoundVars<'tcx>

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

fn fold_binder<T>(&mut self, t: Binder<'tcx, T>) -> Binder<'tcx, T>where Binder<'tcx, T>: TypeSuperFoldable<TyCtxt<'tcx>>,

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

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

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

fn fold_predicate(&mut self, p: Predicate<'tcx>) -> Predicate<'tcx>

Auto Trait Implementations§

impl<'tcx> DynSend for MapAndCompressBoundVars<'tcx>

impl<'tcx> DynSync for MapAndCompressBoundVars<'tcx>

impl<'tcx> Freeze for MapAndCompressBoundVars<'tcx>

impl<'tcx> !RefUnwindSafe for MapAndCompressBoundVars<'tcx>

impl<'tcx> !Send for MapAndCompressBoundVars<'tcx>

impl<'tcx> !Sync for MapAndCompressBoundVars<'tcx>

impl<'tcx> Unpin for MapAndCompressBoundVars<'tcx>

impl<'tcx> !UnwindSafe for MapAndCompressBoundVars<'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>,

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 MapAndCompressBoundVars

fn fold_binder<T>(&mut self, t: Binder<'tcx, T>) -> Binder<'tcx, T>
where Binder<'tcx, T>: TypeSuperFoldable<TyCtxt<'tcx>>,

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,