Struct rustc_infer::infer::combine::CombineFields

pub struct CombineFields<'infcx, 'tcx> {
    pub infcx: &'infcx InferCtxt<'infcx, 'tcx>,
    pub trace: TypeTrace<'tcx>,
    pub cause: Option<Cause>,
    pub param_env: ParamEnv<'tcx>,
    pub obligations: PredicateObligations<'tcx>,
}

Fields

infcx: &'infcx InferCtxt<'infcx, 'tcx>

trace: TypeTrace<'tcx>

cause: Option<Cause>

param_env: ParamEnv<'tcx>

obligations: PredicateObligations<'tcx>

Implementations

impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx>

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

pub fn equate<'a>(&'a mut self, a_is_expected: bool) -> Equate<'a, 'infcx, 'tcx>

pub fn sub<'a>(&'a mut self, a_is_expected: bool) -> Sub<'a, 'infcx, 'tcx>

pub fn lub<'a>(&'a mut self, a_is_expected: bool) -> Lub<'a, 'infcx, 'tcx>

pub fn glb<'a>(&'a mut self, a_is_expected: bool) -> Glb<'a, 'infcx, 'tcx>

pub fn instantiate(
    &mut self,
    a_ty: Ty<'tcx>,
    dir: RelationDir,
    b_vid: TyVid,
    a_is_expected: bool
) -> RelateResult<'tcx, ()>

Here, dir is either EqTo, SubtypeOf, or SupertypeOf. The idea is that we should ensure that the type a_ty is equal to, a subtype of, or a supertype of (respectively) the type to which b_vid is bound.

Since b_vid has not yet been instantiated with a type, we will first instantiate b_vid with a generalized version of a_ty. Generalization introduces other inference variables wherever subtyping could occur.

pub(in infer::combine) fn generalize(
    &self,
    ty: Ty<'tcx>,
    for_vid: TyVid,
    dir: RelationDir
) -> RelateResult<'tcx, Generalization<'tcx>>

Attempts to generalize ty for the type variable for_vid. This checks for cycle -- that is, whether the type ty references for_vid. The dir is the "direction" for which we a performing the generalization (i.e., are we producing a type that can be used as a supertype etc).

Preconditions:

• for_vid is a "root vid"

pub fn add_const_equate_obligation(
    &mut self,
    a_is_expected: bool,
    a: &'tcx Const<'tcx>,
    b: &'tcx Const<'tcx>
)

impl<'a, 'tcx> CombineFields<'a, 'tcx>

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

Trait Implementations

impl<'infcx, 'tcx> Clone for CombineFields<'infcx, 'tcx>

pub fn clone(&self) -> CombineFields<'infcx, 'tcx>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.