Struct rustc_infer::infer::type_variable::TypeVariableTable
source · pub struct TypeVariableTable<'a, 'tcx> {
storage: &'a mut TypeVariableStorage<'tcx>,
undo_log: &'a mut InferCtxtUndoLogs<'tcx>,
}
Fields§
§storage: &'a mut TypeVariableStorage<'tcx>
§undo_log: &'a mut InferCtxtUndoLogs<'tcx>
Implementations§
source§impl<'tcx> TypeVariableTable<'_, 'tcx>
impl<'tcx> TypeVariableTable<'_, 'tcx>
sourcepub fn var_origin(&self, vid: TyVid) -> &TypeVariableOrigin
pub fn var_origin(&self, vid: TyVid) -> &TypeVariableOrigin
Returns the origin that was given when vid
was created.
Note that this function does not return care whether
vid
has been unified with something else or not.
sourcepub fn equate(&mut self, a: TyVid, b: TyVid)
pub fn equate(&mut self, a: TyVid, b: TyVid)
Records that a == b
, depending on dir
.
Precondition: neither a
nor b
are known.
sourcepub fn sub(&mut self, a: TyVid, b: TyVid)
pub fn sub(&mut self, a: TyVid, b: TyVid)
Records that a <: b
, depending on dir
.
Precondition: neither a
nor b
are known.
sourcepub fn instantiate(&mut self, vid: TyVid, ty: Ty<'tcx>)
pub fn instantiate(&mut self, vid: TyVid, ty: Ty<'tcx>)
Instantiates vid
with the type ty
.
Precondition: vid
must not have been previously instantiated.
sourcepub fn new_var(
&mut self,
universe: UniverseIndex,
origin: TypeVariableOrigin
) -> TyVid
pub fn new_var(
&mut self,
universe: UniverseIndex,
origin: TypeVariableOrigin
) -> TyVid
Creates a new type variable.
diverging
: indicates if this is a “diverging” type variable, e.g., one created as the type of areturn
expression. The code in this module doesn’t care if a variable is diverging, but the main Rust type-checker will sometimes “unify” such variables with the!
or()
types.origin
: indicates why the type variable was created. The code in this module doesn’t care, but it can be useful for improving error messages.
sourcepub fn root_var(&mut self, vid: TyVid) -> TyVid
pub fn root_var(&mut self, vid: TyVid) -> TyVid
Returns the “root” variable of vid
in the eq_relations
equivalence table. All type variables that have been equated
will yield the same root variable (per the union-find
algorithm), so root_var(a) == root_var(b)
implies that a == b
(transitively).
sourcepub fn sub_root_var(&mut self, vid: TyVid) -> TyVid
pub fn sub_root_var(&mut self, vid: TyVid) -> TyVid
Returns the “root” variable of vid
in the sub_relations
equivalence table. All type variables that have been are
related via equality or subtyping will yield the same root
variable (per the union-find algorithm), so sub_root_var(a) == sub_root_var(b)
implies that:
exists X. (a <: X || X <: a) && (b <: X || X <: b)
sourcepub fn sub_unified(&mut self, a: TyVid, b: TyVid) -> bool
pub fn sub_unified(&mut self, a: TyVid, b: TyVid) -> bool
Returns true
if a
and b
have same “sub-root” (i.e., exists some
type X such that forall i in {a, b}. (i <: X || X <: i)
.
sourcepub fn probe(&mut self, vid: TyVid) -> TypeVariableValue<'tcx>
pub fn probe(&mut self, vid: TyVid) -> TypeVariableValue<'tcx>
Retrieves the type to which vid
has been instantiated, if
any.
sourcepub fn inlined_probe(&mut self, vid: TyVid) -> TypeVariableValue<'tcx>
pub fn inlined_probe(&mut self, vid: TyVid) -> TypeVariableValue<'tcx>
An always-inlined variant of probe
, for very hot call sites.
sourcepub fn replace_if_possible(&mut self, t: Ty<'tcx>) -> Ty<'tcx>
pub fn replace_if_possible(&mut self, t: Ty<'tcx>) -> Ty<'tcx>
If t
is a type-inference variable, and it has been
instantiated, then return the with which it was
instantiated. Otherwise, returns t
.
fn values(
&mut self
) -> SnapshotVec<Delegate, &mut Vec<TypeVariableData>, &mut InferCtxtUndoLogs<'tcx>>
fn eq_relations(
&mut self
) -> UnificationTable<InPlace<TyVidEqKey<'tcx>, &'_ mut UnificationStorage<TyVidEqKey<'tcx>>, &'_ mut InferCtxtUndoLogs<'tcx>>>
fn sub_relations(
&mut self
) -> UnificationTable<InPlace<TyVid, &'_ mut UnificationStorage<TyVid>, &'_ mut InferCtxtUndoLogs<'tcx>>>
sourcepub fn vars_since_snapshot(
&mut self,
value_count: usize
) -> (Range<TyVid>, Vec<TypeVariableOrigin>)
pub fn vars_since_snapshot(
&mut self,
value_count: usize
) -> (Range<TyVid>, Vec<TypeVariableOrigin>)
Returns a range of the type variables created during the snapshot.
sourcepub fn unsolved_variables(&mut self) -> Vec<TyVid>
pub fn unsolved_variables(&mut self) -> Vec<TyVid>
Returns indices of all variables that are not yet instantiated.
Auto Trait Implementations§
impl<'a, 'tcx> !RefUnwindSafe for TypeVariableTable<'a, 'tcx>
impl<'a, 'tcx> !Send for TypeVariableTable<'a, 'tcx>
impl<'a, 'tcx> !Sync for TypeVariableTable<'a, 'tcx>
impl<'a, 'tcx> Unpin for TypeVariableTable<'a, 'tcx>where
'tcx: 'a,
impl<'a, 'tcx> !UnwindSafe for TypeVariableTable<'a, 'tcx>
Blanket Implementations§
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