Struct rustc_trait_selection::infer::nll_relate::TypeRelating

pub struct TypeRelating<'me, 'tcx, D>
where
    D: TypeRelatingDelegate<'tcx>,
{
    infcx: &'me InferCtxt<'tcx>,
    delegate: D,
    ambient_variance: Variance,
    ambient_variance_info: VarianceDiagInfo<'tcx>,
}

Fields

infcx: &'me InferCtxt<'tcx>

delegate: D

ambient_variance: Variance

ambient_variance_info: VarianceDiagInfo<'tcx>

Implementations

impl<'me, 'tcx, D> TypeRelating<'me, 'tcx, D>

where D: TypeRelatingDelegate<'tcx>,

pub fn new( infcx: &'me InferCtxt<'tcx>, delegate: D, ambient_variance: Variance ) -> TypeRelating<'me, 'tcx, D>

Trait Implementations

impl<'tcx, D> ObligationEmittingRelation<'tcx> for TypeRelating<'_, 'tcx, D>

where D: TypeRelatingDelegate<'tcx>,

fn span(&self) -> Span

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

fn register_predicates( &mut self, obligations: impl IntoIterator> )

where <impl IntoIterator as IntoIterator>::Item: ToPredicate<'tcx>,

Register predicates that must hold in order for this relation to hold. Uses a default obligation cause, ObligationEmittingRelation::register_obligations should be used if control over the obligation causes is required.

fn register_obligations( &mut self, obligations: Vec<Obligation<'tcx, Predicate<'tcx>>> )

Register obligations that must hold in order for this relation to hold

fn alias_relate_direction(&self) -> AliasRelationDirection

Relation direction emitted for AliasRelate predicates, corresponding to the direction of the relation.

fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>)

Register an obligation that both types must be related to each other according to the ty::AliasRelationDirection given by ObligationEmittingRelation::alias_relate_direction

impl<'tcx, D> TypeRelation<'tcx> for TypeRelating<'_, 'tcx, D>

where D: TypeRelatingDelegate<'tcx>,

fn tcx(&self) -> TyCtxt<'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 relate_with_variance<T>( &mut self, variance: Variance, info: VarianceDiagInfo<'tcx>, a: T, b: T ) -> Result<T, TypeError<'tcx>>

where T: Relate<'tcx>,

Switch variance for the purpose of relating a and b.

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

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

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

fn binders<T>( &mut self, a: Binder<'tcx, T>, b: Binder<'tcx, T> ) -> Result<Binder<'tcx, T>, TypeError<'tcx>>

where T: Relate<'tcx>,

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

where F: FnOnce(&mut Self) -> R,

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

where T: Relate<'tcx>,

Generic relation routine suitable for most anything.

fn relate_item_args( &mut self, item_def_id: DefId, a_arg: &'tcx List<GenericArg<'tcx>>, b_arg: &'tcx List<GenericArg<'tcx>> ) -> Result<&'tcx List<GenericArg<'tcx>>, TypeError<'tcx>>

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

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.