Struct ReplaceProjectionWith

struct ReplaceProjectionWith<'a, 'b, I: Interner, D: SolverDelegate<Interner = I>> {
    ecx: &'a mut EvalCtxt<'b, D>,
    param_env: I::ParamEnv,
    self_ty: I::Ty,
    mapping: &'a HashMap<I::DefId, Vec<Binder<I, ProjectionPredicate<I>>>>,
    nested: Vec<Goal<I, I::Predicate>>,
}

Fields

ecx: &'a mut EvalCtxt<'b, D>

param_env: I::ParamEnv

self_ty: I::Ty

mapping: &'a HashMap<I::DefId, Vec<Binder<I, ProjectionPredicate<I>>>>

nested: Vec<Goal<I, I::Predicate>>

Implementations

impl<D, I> ReplaceProjectionWith<'_, '_, I, D>

where D: SolverDelegate<Interner = I>, I: Interner,

fn projection_may_match( &mut self, source_projection: Binder<I, ProjectionPredicate<I>>, target_projection: AliasTerm<I>, ) -> bool

fn try_eagerly_replace_alias( &mut self, alias_term: AliasTerm<I>, ) -> Result<Option<I::Term>, Ambiguous>

Try to replace an alias with the term present in the projection bounds of the self type. Returns Ok<None> if this alias is not eligible to be replaced, or bail with Err(Ambiguous) if it’s uncertain which projection bound to replace the term with due to multiple bounds applying.

Trait Implementations

impl<D, I> FallibleTypeFolder<I> for ReplaceProjectionWith<'_, '_, I, D>

where D: SolverDelegate<Interner = I>, I: Interner,

type Error = Ambiguous

fn cx(&self) -> I

fn try_fold_ty(&mut self, ty: I::Ty) -> Result<I::Ty, Ambiguous>

fn try_fold_binder<T>( &mut self, t: Binder<I, T>, ) -> Result<Binder<I, T>, Self::Error>

where T: TypeFoldable<I>,

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

fn try_fold_const( &mut self, c: <I as Interner>::Const, ) -> Result<<I as Interner>::Const, Self::Error>

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

fn try_fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> Result<<I as Interner>::Clauses, Self::Error>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.