Struct rustc::ty::_match::Match
[−]
[src]
pub struct Match<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> { /* fields omitted */ }
rustc_private
)A type "A" matches "B" if the fresh types in B could be substituted with values so as to make it equal to A. Matching is intended to be used only on freshened types, and it basically indicates if the non-freshened versions of A and B could have been unified.
It is only an approximation. If it yields false, unification would definitely fail, but a true result doesn't mean unification would succeed. This is because we don't track the "side-constraints" on type variables, nor do we track if the same freshened type appears more than once. To some extent these approximations could be fixed, given effort.
Like subtyping, matching is really a binary relation, so the only important thing about the result is Ok/Err. Also, matching never affects any type variables or unification state.
Methods
impl<'a, 'gcx, 'tcx> Match<'a, 'gcx, 'tcx>
[src]
fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Match<'a, 'gcx, 'tcx>
rustc_private
)Trait Implementations
impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Match<'a, 'gcx, 'tcx>
[src]
fn tag(&self) -> &'static str
rustc_private
)Returns a static string we can use for printouts.
fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx>
rustc_private
)fn a_is_expected(&self) -> bool
rustc_private
)Returns true if the value a
is the "expected" type in the relation. Just affects error messages. Read more
fn relate_with_variance<T: Relate<'tcx>>(&mut self,
_: Variance,
a: &T,
b: &T)
-> RelateResult<'tcx, T>
_: Variance,
a: &T,
b: &T)
-> RelateResult<'tcx, T>
rustc_private
)Switch variance for the purpose of relating a
and b
.
fn regions(&mut self,
a: &'tcx Region,
b: &'tcx Region)
-> RelateResult<'tcx, &'tcx Region>
a: &'tcx Region,
b: &'tcx Region)
-> RelateResult<'tcx, &'tcx Region>
rustc_private
)fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>
rustc_private
)fn binders<T>(&mut self,
a: &Binder<T>,
b: &Binder<T>)
-> RelateResult<'tcx, Binder<T>> where T: Relate<'tcx>
a: &Binder<T>,
b: &Binder<T>)
-> RelateResult<'tcx, Binder<T>> where T: Relate<'tcx>
rustc_private
)fn with_cause<F, R>(&mut self, _cause: Cause, f: F) -> R where F: FnOnce(&mut Self) -> R
rustc_private
)fn relate<T: Relate<'tcx>>(&mut self, a: &T, b: &T) -> RelateResult<'tcx, T>
rustc_private
)Generic relation routine suitable for most anything.