Struct rustc_infer::infer::outlives::verify::VerifyBoundCx

pub struct VerifyBoundCx<'cx, 'tcx> {
    tcx: TyCtxt<'tcx>,
    region_bound_pairs: &'cx RegionBoundPairs<'tcx>,
    implicit_region_bound: Option<Region<'tcx>>,
    param_env: ParamEnv<'tcx>,
}

The TypeOutlives struct has the job of "lowering" a T: 'a obligation into a series of 'a: 'b constraints and "verifys", 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

tcx: TyCtxt<'tcx>

region_bound_pairs: &'cx RegionBoundPairs<'tcx>

implicit_region_bound: Option<Region<'tcx>>

param_env: ParamEnv<'tcx>

Implementations

impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx>

pub fn new(
    tcx: TyCtxt<'tcx>,
    region_bound_pairs: &'cx RegionBoundPairs<'tcx>,
    implicit_region_bound: Option<Region<'tcx>>,
    param_env: ParamEnv<'tcx>
) -> Self

pub fn generic_bound(&self, generic: GenericKind<'tcx>) -> VerifyBound<'tcx>

Returns a "verify bound" that encodes what we know about generic and the regions it outlives.

pub(in infer::outlives::verify) fn type_bound(
    &self,
    ty: Ty<'tcx>,
    visited: &mut SsoHashSet<GenericArg<'tcx>>
) -> VerifyBound<'tcx>

pub(in infer::outlives::verify) fn param_bound(
    &self,
    param_ty: ParamTy
) -> VerifyBound<'tcx>

pub fn projection_approx_declared_bounds_from_env(
    &self,
    projection_ty: ProjectionTy<'tcx>
) -> Vec<OutlivesPredicate<Ty<'tcx>, Region<'tcx>>>

Given a projection like T::Item, searches the environment for where-clauses like T::Item: 'a. Returns the set of regions 'a that it finds.

This is an "approximate" check -- it may not find all applicable bounds, and not all the bounds it returns can be relied upon. In particular, this check ignores region identity. So, for example, if we have <T as Trait<'0>>::Item where '0 is a region variable, and the user has <T as Trait<'a>>::Item: 'b in the environment, then the clause from the environment only applies if '0 = 'a, which we don't know yet. But we would still include 'b in this list.

pub fn projection_declared_bounds_from_trait(
    &self,
    projection_ty: ProjectionTy<'tcx>
) -> impl Iterator<Item = Region<'tcx>> + 'cx + Captures<'tcx>

Searches the where-clauses in scope for regions that projection_ty is known to outlive. Currently requires an exact match.

pub fn projection_bound(
    &self,
    projection_ty: ProjectionTy<'tcx>,
    visited: &mut SsoHashSet<GenericArg<'tcx>>
) -> VerifyBound<'tcx>

pub(in infer::outlives::verify) fn recursive_bound(
    &self,
    parent: GenericArg<'tcx>,
    visited: &mut SsoHashSet<GenericArg<'tcx>>
) -> VerifyBound<'tcx>

pub(in infer::outlives::verify) fn declared_generic_bounds_from_env(
    &self,
    generic: GenericKind<'tcx>
) -> Vec<OutlivesPredicate<Ty<'tcx>, Region<'tcx>>>

Searches the environment for where-clauses like G: 'a where G is either some type parameter T or a projection like T::Item. Returns a vector of the 'a bounds it can find.

This is a conservative check -- it may not find all applicable bounds, but all the bounds it returns can be relied upon.

pub(in infer::outlives::verify) fn declared_generic_bounds_from_env_with_compare_fn(
    &self,
    compare_ty: impl Fn(Ty<'tcx>) -> bool
) -> Vec<OutlivesPredicate<Ty<'tcx>, Region<'tcx>>>

pub(in infer::outlives::verify) fn declared_projection_bounds_from_trait(
    &self,
    projection_ty: ProjectionTy<'tcx>
) -> impl Iterator<Item = Region<'tcx>> + 'cx + Captures<'tcx>

Given a projection like <T as Foo<'x>>::Bar, returns any bounds declared in the trait definition. For example, if the trait were

trait Foo<'a> {
    type Bar: 'a;
}

then this function would return 'x. This is subject to the limitations around higher-ranked bounds described in region_bounds_declared_on_associated_item.

pub(in infer::outlives::verify) fn region_bounds_declared_on_associated_item(
    &self,
    assoc_item_def_id: DefId
) -> impl Iterator<Item = Region<'tcx>>

Given the DefId of an associated item, returns any region bounds attached to that associated item from the trait definition.

For example:

trait Foo<'a> {
    type Bar: 'a;
}

If we were given the DefId of Foo::Bar, we would return 'a. You could then apply the substitutions from the projection to convert this into your namespace. This also works if the user writes where <Self as Foo<'a>>::Bar: 'a on the trait. In fact, it works by searching for just such a where-clause.

It will not, however, work for higher-ranked bounds like:

trait Foo<'a, 'b>
where for<'x> <Self as Foo<'x, 'b>>::Bar: 'x
{
    type Bar;
}

This is for simplicity, and because we are not really smart enough to cope with such bounds anywhere.

pub(in infer::outlives::verify) fn collect_outlives_from_predicate_list(
    &self,
    compare_ty: impl Fn(Ty<'tcx>) -> bool,
    predicates: impl Iterator<Item = Predicate<'tcx>>
) -> impl Iterator<Item = OutlivesPredicate<Ty<'tcx>, Region<'tcx>>>

Searches through a predicate list for a predicate T: 'a.

Careful: does not elaborate predicates, and just uses == when comparing ty for equality, so ty must be something that does not involve inference variables and where you otherwise want a precise match.