Struct rustc_middle::ty::_match::Match

pub struct Match<'tcx> {
    tcx: TyCtxt<'tcx>,
    param_env: ParamEnv<'tcx>,
}

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.

Fields

tcx: TyCtxt<'tcx>

param_env: ParamEnv<'tcx>

Implementations

impl<'tcx> Match<'tcx>

pub fn new(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Match<'tcx>

Trait Implementations

impl<'tcx> TypeRelation<'tcx> for Match<'tcx>

pub fn tag(&self) -> &'static str

Returns a static string we can use for printouts.

pub fn tcx(&self) -> TyCtxt<'tcx>

pub fn param_env(&self) -> ParamEnv<'tcx>

pub fn a_is_expected(&self) -> bool

Returns true if the value a is the "expected" type in the relation. Just affects error messages.

pub fn relate_with_variance<T: Relate<'tcx>>(
    &mut self,
    _: Variance,
    a: T,
    b: T
) -> RelateResult<'tcx, T>

Switch variance for the purpose of relating a and b.

pub fn regions(
    &mut self,
    a: Region<'tcx>,
    b: Region<'tcx>
) -> RelateResult<'tcx, Region<'tcx>>

pub fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>

pub fn consts(
    &mut self,
    a: &'tcx Const<'tcx>,
    b: &'tcx Const<'tcx>
) -> RelateResult<'tcx, &'tcx Const<'tcx>>

pub fn binders<T>(
    &mut self,
    a: Binder<T>,
    b: Binder<T>
) -> RelateResult<'tcx, Binder<T>> where
    T: Relate<'tcx>, 

pub fn with_cause<F, R>(&mut self, _cause: Cause, f: F) -> R where
    F: FnOnce(&mut Self) -> R, 

pub fn relate<T: Relate<'tcx>>(&mut self, a: T, b: T) -> RelateResult<'tcx, T>

Generic relation routine suitable for most anything.

pub fn relate_item_substs(
    &mut self,
    item_def_id: DefId,
    a_subst: SubstsRef<'tcx>,
    b_subst: SubstsRef<'tcx>
) -> RelateResult<'tcx, SubstsRef<'tcx>>

Relate the two substitutions for the given item. The default is to look up the variance for the item and proceed accordingly.