Struct Canonicalizer 

pub(super) struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
    delegate: &'a D,
    canonicalize_mode: CanonicalizeMode,
    variables: &'a mut Vec<I::GenericArg>,
    var_kinds: Vec<CanonicalVarKind<I>>,
    variable_lookup_table: HashMap<I::GenericArg, usize>,
    sub_root_lookup_table: HashMap<TyVid, usize>,
    cache: HashMap<I::Ty, I::Ty>,
}

Fields

delegate: &'a D

canonicalize_mode: CanonicalizeMode

variables: &'a mut Vec<I::GenericArg>

var_kinds: Vec<CanonicalVarKind<I>>

variable_lookup_table: HashMap<I::GenericArg, usize>

sub_root_lookup_table: HashMap<TyVid, usize>

Maps each sub_unification_table_root_var to the index of the first variable which used it.

This means in case two type variables have the same sub relations root, we set the sub_root of the second variable to the position of the first. Otherwise the sub_root of each type variable is just its own position.

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

We can simply cache based on the ty itself, because we use ty::BoundVarIndexKind::Canonical.

Implementations

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

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

fn canonicalize_param_env( delegate: &'a D, variables: &'a mut Vec<I::GenericArg>, param_env: I::ParamEnv, ) -> (I::ParamEnv, HashMap<I::GenericArg, usize>, Vec<CanonicalVarKind<I>>)

pub(super) fn canonicalize_input<P: TypeFoldable<I>>( delegate: &'a D, variables: &'a mut Vec<I::GenericArg>, input: QueryInput<I, P>, ) -> 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, 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: I::Region) -> I::Region

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: 144 bytes