Struct rustc::infer::sub::Sub

pub struct Sub<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
    // some fields omitted
}

Unstable (rustc_private)

Ensures a is made a subtype of b. Returns a on success.

Methods

impl<'a, 'gcx, 'tcx> Sub<'a, 'gcx, 'tcx>

fn new(f: CombineFields<'a, 'gcx, 'tcx>) -> Sub<'a, 'gcx, 'tcx>

fn obligations(self) -> PredicateObligations<'tcx>

Trait Implementations

impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Sub<'a, 'gcx, 'tcx>

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

Returns a static string we can use for printouts.

fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx>

fn a_is_expected(&self) -> bool

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

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

fn relate_with_variance<T: Relate<'tcx>>(&mut self, variance: Variance, 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, b: Region) -> RelateResult<'tcx, Region>

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

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

Generic relation routine suitable for most anything.

fn relate_zip<T: Relate<'tcx>>(&mut self, a: &[T], b: &[T]) -> RelateResult<'tcx, Vec<T>>

Relete elements of two slices pairwise.