Trait rustc_middle::ty::relate::Relate

pub trait Relate<'tcx>: TypeFoldable<'tcx> + Copy {
    pub fn relate<R: TypeRelation<'tcx>>(
        relation: &mut R, 
        a: Self, 
        b: Self
    ) -> RelateResult<'tcx, Self>;
}

Required methods

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Self,
    b: Self
) -> RelateResult<'tcx, Self>

Loading content...

Implementations on Foreign Types

impl<'tcx> Relate<'tcx> for Unsafety

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Unsafety,
    b: Unsafety
) -> RelateResult<'tcx, Unsafety>

impl<'tcx> Relate<'tcx> for Abi

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Abi,
    b: Abi
) -> RelateResult<'tcx, Abi>

Loading content...

Implementors

impl<'tcx> Relate<'tcx> for &'tcx Const<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: &'tcx Const<'tcx>,
    b: &'tcx Const<'tcx>
) -> RelateResult<'tcx, &'tcx Const<'tcx>>

impl<'tcx> Relate<'tcx> for &'tcx List<ExistentialPredicate<'tcx>>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Self,
    b: Self
) -> RelateResult<'tcx, Self>

impl<'tcx> Relate<'tcx> for GeneratorWitness<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: GeneratorWitness<'tcx>,
    b: GeneratorWitness<'tcx>
) -> RelateResult<'tcx, GeneratorWitness<'tcx>>

impl<'tcx> Relate<'tcx> for ClosureSubsts<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ClosureSubsts<'tcx>,
    b: ClosureSubsts<'tcx>
) -> RelateResult<'tcx, ClosureSubsts<'tcx>>

impl<'tcx> Relate<'tcx> for ExistentialProjection<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ExistentialProjection<'tcx>,
    b: ExistentialProjection<'tcx>
) -> RelateResult<'tcx, ExistentialProjection<'tcx>>

impl<'tcx> Relate<'tcx> for ExistentialTraitRef<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ExistentialTraitRef<'tcx>,
    b: ExistentialTraitRef<'tcx>
) -> RelateResult<'tcx, ExistentialTraitRef<'tcx>>

impl<'tcx> Relate<'tcx> for FnSig<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: FnSig<'tcx>,
    b: FnSig<'tcx>
) -> RelateResult<'tcx, FnSig<'tcx>>

impl<'tcx> Relate<'tcx> for GeneratorSubsts<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: GeneratorSubsts<'tcx>,
    b: GeneratorSubsts<'tcx>
) -> RelateResult<'tcx, GeneratorSubsts<'tcx>>

impl<'tcx> Relate<'tcx> for ProjectionPredicate<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ProjectionPredicate<'tcx>,
    b: ProjectionPredicate<'tcx>
) -> RelateResult<'tcx, ProjectionPredicate<'tcx>>

impl<'tcx> Relate<'tcx> for ProjectionTy<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: ProjectionTy<'tcx>,
    b: ProjectionTy<'tcx>
) -> RelateResult<'tcx, ProjectionTy<'tcx>>

impl<'tcx> Relate<'tcx> for TraitPredicate<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: TraitPredicate<'tcx>,
    b: TraitPredicate<'tcx>
) -> RelateResult<'tcx, TraitPredicate<'tcx>>

impl<'tcx> Relate<'tcx> for TraitRef<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: TraitRef<'tcx>,
    b: TraitRef<'tcx>
) -> RelateResult<'tcx, TraitRef<'tcx>>

impl<'tcx> Relate<'tcx> for TypeAndMut<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: TypeAndMut<'tcx>,
    b: TypeAndMut<'tcx>
) -> RelateResult<'tcx, TypeAndMut<'tcx>>

impl<'tcx> Relate<'tcx> for GenericArg<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: GenericArg<'tcx>,
    b: GenericArg<'tcx>
) -> RelateResult<'tcx, GenericArg<'tcx>>

impl<'tcx> Relate<'tcx> for Region<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Region<'tcx>,
    b: Region<'tcx>
) -> RelateResult<'tcx, Region<'tcx>>

impl<'tcx> Relate<'tcx> for SubstsRef<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: SubstsRef<'tcx>,
    b: SubstsRef<'tcx>
) -> RelateResult<'tcx, SubstsRef<'tcx>>

impl<'tcx> Relate<'tcx> for Ty<'tcx>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Ty<'tcx>,
    b: Ty<'tcx>
) -> RelateResult<'tcx, Ty<'tcx>>

impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Binder<T>

pub fn relate<R: TypeRelation<'tcx>>(
    relation: &mut R,
    a: Binder<T>,
    b: Binder<T>
) -> RelateResult<'tcx, Binder<T>>

Loading content...