Struct Canonicalizer

pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
    delegate: &'a D,
    canonicalize_mode: CanonicalizeMode,
    variables: &'a mut Vec<I::GenericArg>,
    primitive_var_infos: Vec<CanonicalVarInfo<I>>,
    variable_lookup_table: HashMap<I::GenericArg, usize>,
    binder_index: DebruijnIndex,
    cache: HashMap<(DebruijnIndex, I::Ty), I::Ty>,
}

Fields

delegate: &'a D

canonicalize_mode: CanonicalizeMode

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

primitive_var_infos: Vec<CanonicalVarInfo<I>>

variable_lookup_table: HashMap<I::GenericArg, usize>

binder_index: DebruijnIndex

cache: HashMap<(DebruijnIndex, I::Ty), I::Ty>

We only use the debruijn index during lookup. We don’t need to track the variables as each generic arg only results in a single bound variable regardless of how many times it is encountered.

Implementations

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

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

pub 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>, canonical_var_info: CanonicalVarInfo<I>, ) -> BoundVar

fn finalize(self) -> (UniverseIndex, I::CanonicalVars)

fn cached_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_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>

where T: TypeFoldable<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 as Interner>::Predicate, ) -> <I as Interner>::Predicate

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