Struct rustc_infer::infer::outlives::obligations::TypeOutlives

pub struct TypeOutlives<'cx, 'tcx, D>
where
    D: TypeOutlivesDelegate<'tcx>,
{
    delegate: D,
    tcx: TyCtxt<'tcx>,
    verify_bound: VerifyBoundCx<'cx, 'tcx>,
}

The TypeOutlives struct has the job of “lowering” a T: 'a obligation into a series of 'a: 'b constraints and “verify“s, as described on the module comment. The final constraints are emitted via a “delegate” of type D – this is usually the infcx, which accrues them into the region_obligations code, but for NLL we use something else.

Fields

delegate: D

tcx: TyCtxt<'tcx>

verify_bound: VerifyBoundCx<'cx, 'tcx>

Implementations

impl<'cx, 'tcx, D> TypeOutlives<'cx, 'tcx, D>

where D: TypeOutlivesDelegate<'tcx>,

pub fn new( delegate: D, tcx: TyCtxt<'tcx>, region_bound_pairs: &'cx RegionBoundPairs<'tcx>, implicit_region_bound: Option<Region<'tcx>>, caller_bounds: &'cx [PolyTypeOutlivesPredicate<'tcx>], ) -> Self

pub fn type_must_outlive( &mut self, origin: SubregionOrigin<'tcx>, ty: Ty<'tcx>, region: Region<'tcx>, category: ConstraintCategory<'tcx>, )

Adds constraints to inference such that T: 'a holds (or reports an error if it cannot).

Parameters

• origin, the reason we need this constraint
• ty, the type T
• region, the region 'a

fn components_must_outlive( &mut self, origin: SubregionOrigin<'tcx>, components: &[Component<TyCtxt<'tcx>>], region: Region<'tcx>, category: ConstraintCategory<'tcx>, )

fn param_ty_must_outlive( &mut self, origin: SubregionOrigin<'tcx>, region: Region<'tcx>, param_ty: ParamTy, )

fn placeholder_ty_must_outlive( &mut self, origin: SubregionOrigin<'tcx>, region: Region<'tcx>, placeholder_ty: PlaceholderType, )

fn alias_ty_must_outlive( &mut self, origin: SubregionOrigin<'tcx>, region: Region<'tcx>, alias_ty: AliasTy<'tcx>, )

fn args_must_outlive( &mut self, args: GenericArgsRef<'tcx>, origin: SubregionOrigin<'tcx>, region: Region<'tcx>, opt_variances: Option<&[Variance]>, )

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.