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,
    normalization_goal_source: GoalSource,
    cache: HashMap<I::Ty, I::Ty>,
}

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.

The emitted goals get evaluated in the context of the parent goal; by replacing aliases in nested goals we essentially pull the normalization out of the nested goal. We want to treat the goal as if the normalization still happens inside of the nested goal by inheriting the step_kind of the nested goal and storing it in the GoalSource of the emitted AliasRelate goals. This is necessary for tests/ui/sized/coinductive-1.rs to compile.

Fields

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

param_env: I::ParamEnv

normalization_goal_source: GoalSource

cache: HashMap<I::Ty, I::Ty>

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>, for_goal_source: GoalSource, 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

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.