Trait rustc_middle::ty::relate::TypeRelation

pub trait TypeRelation<'tcx>: Sized {
    // Required methods
    fn tcx(&self) -> TyCtxt<'tcx>;
    fn intercrate(&self) -> bool;
    fn param_env(&self) -> ParamEnv<'tcx>;
    fn tag(&self) -> &'static str;
    fn a_is_expected(&self) -> bool;
    fn mark_ambiguous(&mut self);
    fn relate_with_variance<T: Relate<'tcx>>(
        &mut self,
        variance: Variance,
        info: VarianceDiagInfo<'tcx>,
        a: T,
        b: T
    ) -> RelateResult<'tcx, T>;
    fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>;
    fn regions(
        &mut self,
        a: Region<'tcx>,
        b: Region<'tcx>
    ) -> RelateResult<'tcx, Region<'tcx>>;
    fn consts(
        &mut self,
        a: Const<'tcx>,
        b: Const<'tcx>
    ) -> RelateResult<'tcx, Const<'tcx>>;
    fn binders<T>(
        &mut self,
        a: Binder<'tcx, T>,
        b: Binder<'tcx, T>
    ) -> RelateResult<'tcx, Binder<'tcx, T>>
       where T: Relate<'tcx>;

    // Provided methods
    fn with_cause<F, R>(&mut self, _cause: Cause, f: F) -> R
       where F: FnOnce(&mut Self) -> R { ... }
    fn relate<T: Relate<'tcx>>(&mut self, a: T, b: T) -> RelateResult<'tcx, T> { ... }
    fn relate_item_substs(
        &mut self,
        item_def_id: DefId,
        a_subst: SubstsRef<'tcx>,
        b_subst: SubstsRef<'tcx>
    ) -> RelateResult<'tcx, SubstsRef<'tcx>> { ... }
}

Required Methods

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

fn intercrate(&self) -> bool

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

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

Returns a static string we can use for printouts.

fn a_is_expected(&self) -> bool

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

fn mark_ambiguous(&mut self)

Used during coherence. If called, must emit an always-ambiguous obligation.

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

Switch variance for the purpose of relating a and b.

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

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

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

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

Provided Methods

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

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

Generic relation routine suitable for most anything.

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.

Implementors

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