Type Alias UnificationTable

pub(crate) type UnificationTable<'a, 'tcx, T> = UnificationTable<InPlace<T, &'a mut UnificationStorage<T>, &'a mut InferCtxtUndoLogs<'tcx>>>;

Aliased Type

struct UnificationTable<'a, 'tcx, T> { /* private fields */ }

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

Implementations

impl<S> UnificationTable<S>

where S: UnificationStoreBase + Default,

pub fn new() -> UnificationTable<S>

impl<S> UnificationTable<S>

where S: UnificationStore,

pub fn snapshot(&mut self) -> Snapshot<S>

Starts a new snapshot. Each snapshot must be either rolled back or committed in a “LIFO” (stack) order.

pub fn rollback_to(&mut self, snapshot: Snapshot<S>)

Reverses all changes since the last snapshot. Also removes any keys that have been created since then.

pub fn commit(&mut self, snapshot: Snapshot<S>)

Commits all changes since the last snapshot. Of course, they can still be undone if there is a snapshot further out.

pub fn vars_since_snapshot( &self, snapshot: &Snapshot<S>, ) -> Range<<S as UnificationStoreBase>::Key>

Returns the keys of all variables created since the snapshot.

impl<S> UnificationTable<S>

where S: UnificationStoreBase,

pub fn len(&self) -> usize

Returns the number of keys created so far.

impl<S> UnificationTable<S>

where S: UnificationStoreMut,

pub fn new_key( &mut self, value: <S as UnificationStoreBase>::Value, ) -> <S as UnificationStoreBase>::Key

Creates a fresh key with the given value.

pub fn reserve(&mut self, num_new_keys: usize)

Reserve memory for num_new_keys to be created. Does not actually create the new keys; you must then invoke new_key.

pub fn reset_unifications( &mut self, value: impl FnMut(<S as UnificationStoreBase>::Key) -> <S as UnificationStoreBase>::Value, )

Clears all unifications that have been performed, resetting to the initial state. The values of each variable are given by the closure.

impl<S, K, V> UnificationTable<S>

where S: UnificationStoreBase<Key = K, Value = V>, K: UnifyKey<Value = V>, V: UnifyValue,

//////////////////////////////////////////////////////////////////////// Public API

pub fn try_probe_value<'a, K1>(&'a self, id: K1) -> Option<&'a V>

where K1: Into<K>, K: 'a,

Obtains current value for key without any pointer chasing; may return None if key has been union’d.

impl<S, K, V> UnificationTable<S>

where S: UnificationStoreMut<Key = K, Value = V>, K: UnifyKey<Value = V>, V: UnifyValue,

pub fn union<K1, K2>(&mut self, a_id: K1, b_id: K2)

where K1: Into<K>, K2: Into<K>, V: UnifyValue<Error = NoError>,

Unions two keys without the possibility of failure; only applicable when unify values use NoError as their error type.

pub fn union_value<K1>(&mut self, id: K1, value: V)

where K1: Into<K>, V: UnifyValue<Error = NoError>,

Unions a key and a value without the possibility of failure; only applicable when unify values use NoError as their error type.

pub fn unioned<K1, K2>(&mut self, a_id: K1, b_id: K2) -> bool

where K1: Into<K>, K2: Into<K>,

Given two keys, indicates whether they have been unioned together.

pub fn find<K1>(&mut self, id: K1) -> K

where K1: Into<K>,

Given a key, returns the (current) root key.

pub fn unify_var_var<K1, K2>( &mut self, a_id: K1, b_id: K2, ) -> Result<(), <V as UnifyValue>::Error>

where K1: Into<K>, K2: Into<K>,

Unions together two variables, merging their values. If merging the values fails, the error is propagated and this method has no effect.

pub fn unify_var_value<K1>( &mut self, a_id: K1, b: V, ) -> Result<(), <V as UnifyValue>::Error>

where K1: Into<K>,

Sets the value of the key a_id to b, attempting to merge with the previous value.

pub fn probe_value<K1>(&mut self, id: K1) -> V

where K1: Into<K>,

Returns the current value for the given key. If the key has been union’d, this will give the value from the current root.

pub fn inlined_probe_value<K1>(&mut self, id: K1) -> V

where K1: Into<K>,

Trait Implementations

impl<S> Clone for UnificationTable<S>

where S: Clone + UnificationStoreBase,

fn clone(&self) -> UnificationTable<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for UnificationTable<S>

where S: Debug + UnificationStoreBase,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S> Default for UnificationTable<S>

where S: Default + UnificationStoreBase,

fn default() -> UnificationTable<S>

Returns the “default value” for a type.