Struct rustc_trait_selection::infer::outlives::env::OutlivesEnvironment

pub struct OutlivesEnvironment<'tcx> {
    pub param_env: ParamEnv<'tcx>,
    pub(in infer::outlives::env) free_region_map: FreeRegionMap<'tcx>,
    pub(in infer::outlives::env) region_bound_pairs_map: HashMap<HirId, Vec<(&'tcx RegionKind, GenericKind<'tcx>)>, BuildHasherDefault<FxHasher>>,
    pub(in infer::outlives::env) region_bound_pairs_accum: Vec<(&'tcx RegionKind, GenericKind<'tcx>)>,
}

The OutlivesEnvironment collects information about what outlives what in a given type-checking setting. For example, if we have a where-clause like where T: 'a in scope, then the OutlivesEnvironment would record that (in its region_bound_pairs field). Similarly, it contains methods for processing and adding implied bounds into the outlives environment.

Other code at present does not typically take a &OutlivesEnvironment, but rather takes some of its fields (e.g., process_registered_region_obligations wants the region-bound-pairs). There is no mistaking it: the current setup of tracking region information is quite scattered! The OutlivesEnvironment, for example, needs to sometimes be combined with the middle::RegionRelations, to yield a full picture of how (lexical) lifetimes interact. However, I'm reluctant to do more refactoring here, since the setup with NLL is quite different. For example, NLL has no need of RegionRelations, and is solely interested in the OutlivesEnvironment. -nmatsakis

Fields

param_env: ParamEnv<'tcx>

free_region_map: FreeRegionMap<'tcx>

region_bound_pairs_map: HashMap<HirId, Vec<(&'tcx RegionKind, GenericKind<'tcx>)>, BuildHasherDefault<FxHasher>>

region_bound_pairs_accum: Vec<(&'tcx RegionKind, GenericKind<'tcx>)>

Trait Implementations

impl<'tcx> OutlivesEnvironmentExt<'tcx> for OutlivesEnvironment<'tcx>

pub fn add_implied_bounds<'a>(
    &mut self,
    infcx: &InferCtxt<'a, 'tcx>,
    fn_sig_tys: &[Ty<'tcx>],
    body_id: HirId,
    span: Span
)

This method adds "implied bounds" into the outlives environment. Implied bounds are outlives relationships that we can deduce on the basis that certain types must be well-formed -- these are either the types that appear in the function signature or else the input types to an impl. For example, if you have a function like

fn foo<'a, 'b, T>(x: &'a &'b [T]) { }

we can assume in the caller's body that 'b: 'a and that T: 'b (and hence, transitively, that T: 'a). This method would add those assumptions into the outlives-environment.

Tests: src/test/compile-fail/regions-free-region-ordering-*.rs