Struct rustc::infer::outlives::env::OutlivesEnvironment

pub struct OutlivesEnvironment<'tcx> { /* fields omitted */ }

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

Methods

impl<'a, 'gcx: 'tcx, 'tcx: 'a> OutlivesEnvironment<'tcx>

pub fn new(param_env: ParamEnv<'tcx>) -> Self

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn free_region_map(&self) -> &FreeRegionMap<'tcx>

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Borrows current value of the free_region_map.

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

pub fn region_bound_pairs(&self) -> &[(Region<'tcx>, GenericKind<'tcx>)]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Borrows current value of the region_bound_pairs.

pub fn into_free_region_map(self) -> FreeRegionMap<'tcx>

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Returns ownership of the free_region_map.

pub fn push_snapshot_pre_closure(&self) -> usize

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

This is a hack to support the old-skool regionck, which processes region constraints from the main function and the closure together. In that context, when we enter a closure, we want to be able to "save" the state of the surrounding a function. We can then add implied bounds and the like from the closure arguments into the environment -- these should only apply in the closure body, so once we exit, we invoke pop_snapshot_post_closure to remove them.

Example:

fn foo<T>() {
   callback(for<'a> |x: &'a T| {
        // ^^^^^^^ not legal syntax, but probably should be
        // within this closure body, `T: 'a` holds
   })
}

This "containment" of closure's effects only works so well. In particular, we (intentionally) leak relationships between free regions that are created by the closure's bounds. The case where this is useful is when you have (e.g.) a closure with a signature like for<'a, 'b> fn(x: &'a &'b u32) -- in this case, we want to keep the relationship 'b: 'a in the free-region-map, so that later if we have to take LUB('b, 'a) we can get the result 'b.

I have opted to keep all modifications to the free-region-map, however, and not just those that concern free variables bound in the closure. The latter seems more correct, but it is not the existing behavior, and I could not find a case where the existing behavior went wrong. In any case, it seems like it'd be readily fixed if we wanted. There are similar leaks around givens that seem equally suspicious, to be honest. --nmatsakis

pub fn pop_snapshot_post_closure(&mut self, len: usize)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

See push_snapshot_pre_closure.

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

Trait Implementations

impl<'tcx> Clone for OutlivesEnvironment<'tcx>

fn clone(&self) -> OutlivesEnvironment<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.