Struct Canonicalizer 

pub(super) struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
    delegate: &'a D,
    canonicalize_mode: CanonicalizeMode,
    state: CanonicalizerState<I>,
}

Fields

delegate: &'a D

canonicalize_mode: CanonicalizeMode

state: CanonicalizerState<I>

Implementations

impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I>

fn new(delegate: &'a D, canonicalize_mode: CanonicalizeMode) -> Self

pub(super) fn canonicalize_response<T: TypeFoldable<I>>( delegate: &'a D, max_input_universe: UniverseIndex, value: T, ) -> Canonical<I, T>

fn canonicalize_param_env( delegate: &'a D, param_env: I::ParamEnv, ) -> (I::ParamEnv, Self)

pub(super) fn canonicalize_input<P: TypeFoldable<I>>( delegate: &'a D, input: QueryInput<I, P>, ) -> (ThinVec<I::GenericArg>, Canonical<I, QueryInput<I, P>>)

When canonicalizing query inputs, we keep 'static in the param_env but erase it everywhere else. We generally don’t want to depend on region identity, so while it should not matter whether 'static is kept in the value or opaque type storage as well, this prevents us from accidentally relying on it in the future.

We want to keep the option of canonicalizing 'static to an existential variable in the future by changing the way we detect global where-bounds.

fn get_or_insert_bound_var( &mut self, arg: impl Into<I::GenericArg>, kind: CanonicalVarKind<I>, ) -> BoundVar

fn get_or_insert_sub_root(&mut self, vid: TyVid) -> BoundVar

fn finalize( self, ) -> (UniverseIndex, ThinVec<I::GenericArg>, I::CanonicalVarKinds)

fn inner_fold_ty(&mut self, t: I::Ty) -> I::Ty

Trait Implementations

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

fn cx(&self) -> I

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

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

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

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

fn fold_clauses(&mut self, c: I::Clauses) -> I::Clauses

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

where T: TypeFoldable<I>,

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 152 bytes